iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 09:41:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

- fix merge swift conflict

Browse Source 
- Merge master
This commit is contained in:
C. Bess 2014-09-02 18:52:04 -05:00
commit 313c0daf05
8 changed files with 425 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bash.html.markdown
View File

@ -73,9 +73,9 @@ echo Hello, $NAME!
# use 'man test' for more info about conditionals # use 'man test' for more info about conditionals
if [ $NAME -ne $USER ] if [ $NAME -ne $USER ]
then then
echo "Your name is your username"
else
echo "Your name isn't your username" echo "Your name isn't your username"
else
echo "Your name is your username"
fi fi
# There is also conditional execution # There is also conditional execution

120
es-es/perl-es.html.markdown
View File

@ -7,23 +7,24 @@ contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"] - ["Korjavin Ivan", "http://github.com/korjavin"]
translators: translators:
- ["Francisco Gomez", "http://github.com/frncscgmz"] - ["Francisco Gomez", "http://github.com/frncscgmz"]
- ["Joaquín Ferrero", "http://github.com/joaquinferrero"]
lang: es-es lang: es-es
--- ---
Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas de 25 años de desarrollo. Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo.
Perl 5 corre en mas de 100 plataformas desde portales hasta mainframes y es adecuado para realizar prototipos rápidos hasta desarrollar proyectos a gran escala. Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala.
```perl ```perl
# Comentarios de una sola linea con un carácter hash. # Comentarios de una sola línea con un carácter hash
#### Tipos de variables en Perl #### Tipos de variables en Perl
# Las variables comienzan con el símbolo $. # Las variables comienzan con el símbolo $
# Un nombre de variable valido empieza con una letra o un guión bajo, # Un nombre de variable válido empieza con una letra o un guión bajo,
# seguido por cualquier numero de letras, números o guiones bajos. # seguido por cualquier número de letras, números o guiones bajos
### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes. ### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes
## Escalares ## Escalares
# Un escalar representa un solo valor: # Un escalar representa un solo valor:
@ -31,99 +32,98 @@ my $animal = "camello";
my $respuesta = 42; my $respuesta = 42;
# Los valores escalares pueden ser cadenas de caracteres, números enteros o # Los valores escalares pueden ser cadenas de caracteres, números enteros o
# de punto flotante, Perl automáticamente los convertirá como sea requerido. # de punto flotante; Perl automáticamente los convertirá como sea requerido
## Arreglos ## Arreglos
# Un arreglo representa una lista de valores: # Un arreglo representa una lista de valores:
my @animales = {"camello","llama","buho"}; my @animales = ("camello","llama","buho"};
my @numeros = {23,42,69}; my @numeros = (23, 42, 69);
my @mixto = {"camello",42,1.23}; my @mixto = ("camello", 42, 1.23);
## Hashes ## Hashes
# Un hash representa un conjunto de pares llave/valor: # Un hash representa un conjunto de pares llave/valor:
my %color_fruta = ("manzana","rojo","banana","amarillo");
my %color_fruta = {"manzana","rojo","banana","amarillo"};
# Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas
# fácilmente.
# Puede usar un espacio en blanco y el operador "=>" para asignarlos más fácilmente
my %color_fruta = ( my %color_fruta = (
manzana => "rojo", manzana => "rojo",
banana => "amarillo", banana => "amarillo",
); );
# Los escalares, arreglos y hashes están mas documentados en perldata. (perldoc perldata).
# Los tipos de datos mas complejos pueden ser construidos utilizando # Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata)
# referencias, las cuales te permiten construir listas y hashes dentro
# de listas y hashes. # Los tipos de datos más complejos se pueden construir utilizando
# referencias, las cuales le permiten construir listas y hashes dentro
# de listas y hashes
#### Estructuras condicionales y de ciclos #### Estructuras condicionales y de ciclos
# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas comunes. # Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes
if ( $var ) { if ( $var ) {
... ...;
} elsif ( $var eq 'bar' ) { } elsif ( $var eq 'bar' ) {
... ...;
} else { } else {
... ...;
} }
unless ( condicion ) { unless ( condicion ) {
... ...;
} }
# Esto es proporcionado como una version mas fácil de leer que "if (!condición)"
# La post condición al modo Perl # Esto se ofrece como una versión más fácil de leer que "if (!condición)"
# La postcondición al modo Perl:
print "Yow!" if $zippy; print "Yow!" if $zippy;
print "No tenemos bananas" unless $bananas; print "No tenemos bananas" unless $bananas;
# while # while
while ( condicion ) { while ( condicion ) {
... ...;
} }
# for y foreach # for y foreach
for ($i = 0; $i <= $max; $i++) { for ($i = 0; $i <= $max; $i++) {
... ...;
} }
for $i (0 .. $max) {
...;
}
foreach (@array) { foreach (@array) {
print "Este elemento es $_\n"; print "Este elemento es $_\n";
} }
#### Expresiones regulares #### Expresiones regulares
# El soporte de expresiones regulares en Perl es muy amplio y profundo, y es # El soporte de expresiones regulares en Perl es muy amplio y profundo, y
# sujeto a una extensa documentación en perlrequick, perlretut, entre otros. # está sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
# Sin embargo, resumiendo: # Sin embargo, resumiendo:
# Pareo simple # Coincidencia simple
if (/foo/) { ... } # verdadero si $_ contiene "foo" if (/foo/) { ... } # verdadero si $_ contiene "foo"
if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo" if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo"
# Substitución simple # Substitución simple
$a =~ s/foo/bar/; # remplaza foo con bar en $a $a =~ s/foo/bar/; # remplaza "foo" con "bar" en $a
$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de foo con bar en $a $a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en $a
#### Archivos e I/O #### Archivos y E/S
# Puedes abrir un archivo para obtener datos o escribirlos utilizando la # Puede abrir un archivo para obtener datos o escribirlos utilizando la
# función "open()". # función "open()"
open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!"; open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!";
open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!"; open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!";
open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!"; open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!";
# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>" # Es posible leer desde un gestor de archivo abierto utilizando el operador "<>".
# operador. En contexto escalar leer una sola linea desde el gestor de # En contexto escalar, leer una sola línea desde el gestor de archivo, y
# archivo, y en contexto de lista leer el archivo completo en donde, asigna # en contexto de lista, leer el archivo completo en donde asigna
# cada linea a un elemento de la lista. # cada línea a un elemento de la lista
my $linea = <$entrada>; my $linea = <$entrada>;
my @lineas = <$entrada>; my @lineas = <$entrada>;
@ -131,30 +131,26 @@ my @lineas = <$entrada>;
#### Escribiendo subrutinas #### Escribiendo subrutinas
# Escribir subrutinas es fácil: # Escribir subrutinas es fácil:
sub logger { sub logger {
my $mensajelog = shift; my $mensajelog = shift;
open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!"; open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!";
print $archivolog $mensajelog; print $archivolog $mensajelog;
} }
# Ahora podemos utilizar la subrutina al igual que cualquier otra función # Ahora podemos utilizar la subrutina al igual que cualquier otra función incorporada:
# incorporada:
logger("Tenemos una subrutina logger!"); logger("Tenemos una subrutina logger!");
``` ```
#### Utilizando módulos Perl #### Utilizando módulos Perl
Los módulos en Perl proveen una gama de funciones que te pueden ayudar a evitar reinventar la rueda, estas pueden ser descargadas desde CPAN( http://www.cpan.org/ ). Algunos de los módulos mas populares ya están incluidos con la misma distribución de Perl. Los módulos en Perl proveen de una gama de funciones que le pueden ayudar a evitar reinventar la rueda. Éstas se pueden descargar desde CPAN ( http://www.cpan.org/ ). Algunos de los módulos más populares ya están incluidos con la misma distribución de Perl.
perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar. perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos de CPAN que puede usar.
#### Material de Lectura #### Material de Lectura
- [perl-tutorial](http://perl-tutorial.org/) - [perl-tutorial](http://perl-tutorial.org/)
- [Aprende en www.perl.com](http://www.perl.org/learn.html) - [Learn Perl](http://www.perl.org/learn.html)
- [perldoc](http://perldoc.perl.org/) - [perldoc](http://perldoc.perl.org/)
- y perl incorporado: `perldoc perlintro` - y en su propio perl: `perldoc perlintro`

2
java.html.markdown
View File

@ -101,7 +101,7 @@ public class LearnJava {
// Arrays // Arrays
//The array size must be decided upon instantiation //The array size must be decided upon instantiation
//The following formats work for declaring an arrow //The following formats work for declaring an array
//<datatype> [] <var name> = new <datatype>[<array size>]; //<datatype> [] <var name> = new <datatype>[<array size>];
//<datatype> <var name>[] = new <datatype>[<array size>]; //<datatype> <var name>[] = new <datatype>[<array size>];
int [] intArray = new int[10]; int [] intArray = new int[10];

9
perl6.html.markdown
View File

@ -488,6 +488,7 @@ sub truthy-array(@array) {
# (it'll stop at the furthest operator in the current expression) # (it'll stop at the furthest operator in the current expression)
my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }` my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }`
my @arrayplus3 = map(*+*+3, @array); # Same as `-> $a, $b { $a + $b + 3 }` my @arrayplus3 = map(*+*+3, @array); # Same as `-> $a, $b { $a + $b + 3 }`
# also `sub ($a, $b) { $a + $b + 3 }`
say (*/2)(4); #=> 2 say (*/2)(4); #=> 2
# Immediatly execute the function Whatever created. # Immediatly execute the function Whatever created.
say ((*+3)/5)(5); #=> 1.6 say ((*+3)/5)(5); #=> 1.6
@ -496,7 +497,8 @@ say ((*+3)/5)(5); #=> 1.6
# But if you need to have more than one argument (`$_`) # But if you need to have more than one argument (`$_`)
# in a block (without wanting to resort to `-> {}`), # in a block (without wanting to resort to `-> {}`),
# you can also use the implicit argument syntax, `$^` : # you can also use the implicit argument syntax, `$^` :
map({ $^a + $^b + 3 }, @array); # same as the above map({ $^a + $^b + 3 }, @array); # equivalent to following:
map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`)
# Note : those are sorted lexicographically. # Note : those are sorted lexicographically.
# `{ $^b / $^a }` is like `-> $a, $b { $b / $a }` # `{ $^b / $^a }` is like `-> $a, $b { $b / $a }`
@ -1072,6 +1074,11 @@ my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above)
my @fib = 1, 1, *+* ... *; # lazy infinite list of prime numbers, my @fib = 1, 1, *+* ... *; # lazy infinite list of prime numbers,
# computed using a closure! # computed using a closure!
my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above) my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above)
my @fib = 1, 1, { $^a + $^b } ... *; #(... also equivalent to the above)
# $a and $b will always take the previous values, meaning here
# they'll start with $a = 1 and $b = 1 (values we set by hand).
# then $a = 1 and $b = 2 (result from previous $a+$b), and so on.
say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55 say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
# (using a range as the index) # (using a range as the index)
# Note : as for ranges, once reified, elements aren't re-calculated. # Note : as for ranges, once reified, elements aren't re-calculated.

195
purescript.html.markdown Normal file
View File

@ -0,0 +1,195 @@
---
language: purescript
contributors:
- ["Fredrik Dyrkell", "http://www.lexicallyscoped.com"]
---
PureScript is a small strongly, statically typed language compiling to Javascript.
* Learn more at [http://www.purescript.org/](http://www.purescript.org/)
* Documentation: [http://docs.purescript.org/en/latest/](http://docs.purescript.org/en/latest/)
* Book: Purescript by Example, [https://leanpub.com/purescript/](https://leanpub.com/purescript/)
```haskell
--
-- 1. Primitive datatypes that corresponds to their Javascript
-- equivalents at runtime.
-- Numbers
1 + 7*5 :: Number -- 36
-- Types are inferred, so the following works fine
9 / 2.5 + 4.4 -- 8
-- Hexadecimal literals
0xff + 1 -- 256
-- Unary negation
6 * -3 -- -18
6 * negate 3 -- -18
-- Modulus
3 % 2 -- 1
4 % 2 -- 0
-- Inspect the type of an expression in psci
:t 9 / 2.5 + 4.4 -- Prim.Number
-- Booleans
true :: Boolean -- true
false :: Boolean -- false
-- Negation
not true --false
23 == 23 -- true
1 /= 4 -- true
1 >= 4 -- false
-- Comparisions < <= > >=
-- are defined in terms of compare
compare 1 2 -- LT
compare 2 2 -- EQ
compare 3 2 -- GT
-- Conjunction and Disjunction
true && (9 >= 19 || 1 < 2) -- true
-- Strings
"Hellow" :: String -- "Hellow"
-- Multiline string
"Hellow\
\orld" -- "Helloworld"
-- Concatenate
"such " ++ "amaze" -- "such amaze"
--
-- 2. Arrays are Javascript arrays, but must be homogeneous
[1,1,2,3,5,8] :: [Number] -- [1,1,2,3,5,8]
[true, true, false] :: [Boolean] -- [true,true,false]
-- [1,2, true, "false"] won't work
-- `Cannot unify Prim.Number with Prim.Boolean`
-- Cons (prepend)
1 : [2,4,3] -- [1,2,4,3]
-- Requires purescript-arrays (Data.Array)
-- and purescript-maybe (Data.Maybe)
-- Safe access return Maybe a
head [1,2,3] -- Just (1)
tail [3,2,1] -- Just ([2,1])
init [1,2,3] -- Just ([1,2])
last [3,2,1] -- Just (1)
-- Random access - indexing
[3,4,5,6,7] !! 2 -- Just (5)
-- Range
1..5 -- [1,2,3,4,5]
length [2,2,2] -- 3
drop 3 [5,4,3,2,1] -- [2,1]
take 3 [5,4,3,2,1] -- [5,4,3]
append [1,2,3] [4,5,6] -- [1,2,3,4,5,6]
--
-- 3. Records are Javascript objects, with zero or more fields, which
-- can have different types
let book = {title: "Foucault's pendulum", author: "Umberto Eco"}
-- Access properties
book.title -- "Foucault's pendulum"
getTitle b = b.title
-- Works on all records with a title (but doesn't require any other field)
getTitle book -- "Foucault's pendulum"
getTitle {title: "Weekend in Monaco", artist: "The Rippingtons"} -- "Weekend in Monaco"
-- Update a record
changeTitle b t = b {title = t}
changeTitle book "Ill nome della rosa" -- {title: "Ill nome della
-- rosa", author: "Umberto Eco"}
--
-- 4. Functions
sumOfSquares x y = x*x+y*y
sumOfSquares 3 4 -- 25
-- In psci you have to write `let` in front of the function to get a
-- top level binding
mod x y = x % y
mod 3 2 -- 1
-- Infix application of function
3 `mod` 2 -- 1
-- function application have higher precedence than all other
-- operators
sumOfSquares 3 4 * sumOfSquares 4 5 -- 1025
-- Conditional
abs' n = if n>=0 then n else -n
abs' (-3) -- 3
-- Guarded equations
abs n | n >= 0 = n
| otherwise = -n
-- Pattern matching
-- Note the type signature, input is an array of numbers The pattern
-- matching destructures and binds the array into parts
first :: [Number] -> Number
first (x:_) = x
first [3,4,5] -- 3
second :: [Number] -> Number
second (_:y:_) = y
second [3,4,5] -- 4
sumTwo :: [Number] -> [Number]
sumTwo (x:y:rest) = (x+y) : rest
sumTwo [2,3,4,5,6] -- [5,4,5,6]
-- sumTwo doesn't handle when the array is empty or just have one
-- element in which case you get an error
sumTwo [1] -- Failed pattern match
-- Complementing patterns to match
-- Good ol' Fibonacci
fib 1 = 1
fib 2 = 2
fib x = fib (x-1) + fib (x-2)
fib 10 -- 89
-- Use underscore to match any, where you don't care about the binding name
isZero 0 = true
isZero _ = false
-- Pattern matching on records
ecoTitle {author = "Umberto Eco", title = t} = Just t
ecoTitle _ = Nothing
ecoTitle book -- Just ("Foucault's pendulum")
ecoTitle {title: "The Quantum Thief", author: "Hannu Rajaniemi"} -- Nothing
-- ecoTitle requires both field to type check:
ecoTitle {title: "The Quantum Thief"} -- Object does not have property author
-- Lambda expressions
(\x -> x*x) 3 -- 9
(\x y -> x*x + y*y) 4 5 -- 41
sqr = \x -> x*x
-- Currying
add x y = x + y -- is equivalent with
add = \x -> (\y -> x+y)
add3 = add 3
:t add3 -- Prim.Number -> Prim.Number
-- Forward and backward function composition
-- drop 3 followed by taking 5
(drop 3 >>> take 5) (1..20) -- [4,5,6,7,8]
-- take 5 followed by dropping 3
(drop 3 <<< take 5) (1..20) -- [4,5]
-- Operations using higher order functions
even x = x % 2 == 0
filter even (1..10) -- [2,4,6,8,10]
map (\x -> x+11) (1..5) -- [12,13,14,15,16]
-- Requires purescript-foldable-traversabe (Data.Foldable)
foldr (+) 0 (1..10) -- 55
sum (1..10) -- 55
product (1..10) -- 3628800
-- Testing with predicate
any even [1,2,3] -- true
all even [1,2,3] -- false
```

2
scala.html.markdown
View File

@ -243,7 +243,7 @@ i // Show the value of i. Note that while is a loop in the classical sense -
// A do while loop // A do while loop
do { do {
println("x is still less then 10"); println("x is still less than 10");
x += 1 x += 1
} while (x < 10) } while (x < 10)

4
swift.html.markdown
View File

@ -60,7 +60,7 @@ var occupations = [
"kaylee": "Mechanic" "kaylee": "Mechanic"
] ]
occupations["Jayne"] = "Public Relations" occupations["Jayne"] = "Public Relations"
let emptyDictionary = Dictionary<String, Float>() let emptyDictionary = [String: Float]()
// //
@ -226,7 +226,6 @@ public class Shape {
// If you just need to store data in a // If you just need to store data in a
// structured object, you should use a `struct` // structured object, you should use a `struct`
// A simple class `Square` extends `Shape`
internal class Rect: Shape { internal class Rect: Shape {
var sideLength: Int = 1 var sideLength: Int = 1
@ -271,6 +270,7 @@ internal class Rect: Shape {
} }
} }
// A simple class `Square` extends `Rect`
class Square: Rect { class Square: Rect {
convenience init() { convenience init() {
self.init(sideLength: 5) self.init(sideLength: 5)

158
typescript.html.markdown Normal file
View File

@ -0,0 +1,158 @@
---
language: TypeScript
contributors:
- ["Philippe Vlérick", "https://github.com/pvlerick"]
filename: learntypescript.ts
---
TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
This article will focus only on TypeScript extra syntax, as oposed to [JavaScript] (../javascript/).
To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript.
```ts
//There are 3 basic types in TypeScript
var isDone: boolean = false;
var lines: number = 42;
var name: string = "Anders";
//..When it's impossible to know, there is the "Any" type
var notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean
//For collections, there are typed arrays and generic arrays
var list: number[] = [1, 2, 3];
//Alternatively, using the generic array type
var list: Array<number> = [1, 2, 3];
//For enumerations:
enum Color {Red, Green, Blue};
var c: Color = Color.Green;
//Lastly, "void" is used in the special case of a function not returning anything
function bigHorribleAlert(): void {
alert("I'm a little annoying box!");
}
//Functions are first class citizens, support the lambda "fat arrow" syntax and use type inference
//All examples are equivalent, the same signature will be infered by the compiler, and same JavaScript will be emitted
var f1 = function(i: number) : number { return i * i; }
var f2 = function(i: number) { return i * i; } //Return type infered
var f3 = (i : number) : number => { return i * i; }
var f4 = (i: number) => { return i * i; } //Return type infered
var f5 = (i: number) => i * i; //Return type infered, one-liner means no return keyword needed
//Interfaces are structural, anything that has the properties is compliant with the interface
interface Person {
name: string;
//Optional properties, marked with a "?"
age?: number;
//And of course functions
move(): void;
}
//..Object that implements the "Person" interface
var p : Person = { name: "Bobby", move : () => {} }; //Can be treated as a Person since it has the name and age properties
//..Objects that have the optional property:
var validPerson : Person = { name: "Bobby", age: 42, move: () => {} };
var invalidPerson : Person = { name: "Bobby", age: true }; //Is not a person because age is not a number
//..Interfaces can also describe a function type
interface SearchFunc {
(source: string, subString: string): boolean;
}
//..Only the parameters' types are important, names are not important.
var mySearch: SearchFunc;
mySearch = function(src: string, sub: string) {
return src.search(sub) != -1;
}
//Classes - members are public by default
class Point {
//Properties
x: number;
//Constructor - the public/private keywords in this context will generate the boiler plate code
// for the property and the initialization in the constructor.
// In this example, "y" will be defined just like "x" is, but with less code
//Default values are also supported
constructor(x: number, public y: number = 0) {
this.x = x;
}
//Functions
dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
//Static members
static origin = new Point(0, 0);
}
var p1 = new Point(10 ,20);
var p2 = new Point(25); //y will be 0
//Inheritance
class Point3D extends Point {
constructor(x: number, y: number, public z: number = 0) {
super(x, y); //Explicit call to the super class constructor is mandatory
}
//Overwrite
dist() {
var d = super.dist();
return Math.sqrt(d * d + this.z * this.z);
}
}
//Modules, "." can be used as separator for sub modules
module Geometry {
export class Square {
constructor(public sideLength: number = 0) {
}
area() {
return Math.pow(this.sideLength, 2);
}
}
}
var s1 = new Geometry.Square(5);
//..Local alias for referencing a module
import G = Geometry;
var s2 = new G.Square(10);
//Generics
//..Classes
class Tuple<T1, T2> {
constructor(public item1: T1, public item2: T2) {
}
}
//..Interfaces
interface Pair<T> {
item1: T;
item2: T;
}
//..And functions
var pairToTuple = function<T>(p: Pair<T>) {
return new Tuple(p.item1, p.item2);
};
var tuple = pairToTuple({ item1:"hello", item2:"world"});
//Including references to a definition file:
/// <reference path="jquery.d.ts" />
```
## Further Reading
* [TypeScript Official website] (http://www.typescriptlang.org/)
* [TypeScript language specifications (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
* [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
* [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
* [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)