info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-08-12 09:44:24 +02:00
Code Issues Releases Wiki Activity

Merged with latest from upstream

Browse Source
This commit is contained in:
Adam
2013-10-27 22:18:31 -07:00
parent 7ff3de74fe 0c523f4e95
commit dadd4c2a2b
6 changed files with 592 additions and 317 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
bash.html.markdown
View File

@@ -117,7 +117,7 @@ done
# You can also define functions # You can also define functions
# Definition: # Definition:
foo () function foo ()
{ {
echo "Arguments work just like script arguments: $@" echo "Arguments work just like script arguments: $@"
echo "And: $1 $2..." echo "And: $1 $2..."
@@ -125,6 +125,13 @@ foo ()
return 0 return 0
} }
# or simply
bar ()
{
echo "Another way to declare functions!"
return 0
}
# Calling your function # Calling your function
foo "My name is" $NAME foo "My name is" $NAME

519
csharp.html.markdown
View File

@@ -4,6 +4,7 @@ contributors:
- ["Irfan Charania", "https://github.com/irfancharania"] - ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"] - ["Max Yankov", "https://github.com/golergka"]
- ["Melvyn Laïly", "http://x2a.yt"] - ["Melvyn Laïly", "http://x2a.yt"]
- ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
filename: LearnCSharp.cs filename: LearnCSharp.cs
--- ---
@@ -23,7 +24,12 @@ Multi-line comments look like this
// Specify namespaces application will be using // Specify namespaces application will be using
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Entity;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Threading.Tasks;
// defines scope to organize code into "packages" // defines scope to organize code into "packages"
namespace Learning namespace Learning
@@ -32,8 +38,8 @@ namespace Learning
// you're allowed to do otherwise, but shouldn't for sanity. // you're allowed to do otherwise, but shouldn't for sanity.
public class LearnCSharp public class LearnCSharp
{ {
// A console application must have a main method as an entry point // BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
public static void Main(string[] args) public static void Syntax()
{ {
// Use Console.WriteLine to print lines // Use Console.WriteLine to print lines
Console.WriteLine("Hello World"); Console.WriteLine("Hello World");
@@ -46,7 +52,6 @@ namespace Learning
Console.Write("Hello "); Console.Write("Hello ");
Console.Write("World"); Console.Write("World");
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
// Types & Variables // Types & Variables
// //
@@ -61,140 +66,83 @@ namespace Learning
// (0 <= byte <= 255) // (0 <= byte <= 255)
byte fooByte = 100; byte fooByte = 100;
// Short - Signed 16-bit integer // Short - 16-bit integer
// (-32,768 <= short <= 32,767) // Signed - (-32,768 <= short <= 32,767)
// Unsigned - (0 <= ushort <= 65,535)
short fooShort = 10000; short fooShort = 10000;
// Ushort - Unsigned 16-bit integer
// (0 <= ushort <= 65,535)
ushort fooUshort = 10000; ushort fooUshort = 10000;
// Integer - Signed 32-bit integer // Integer - 32-bit integer
// (-2,147,483,648 <= int <= 2,147,483,647) int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
int fooInt = 1; uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
// Uinteger - Unsigned 32-bit integer // Long - 64-bit integer
// (0 <= uint <= 4,294,967,295) long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
uint fooUint = 1; ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
// Numbers default to being int or uint depending on size.
// Long - Signed 64-bit integer
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L;
// L is used to denote that this variable value is of type long or ulong // L is used to denote that this variable value is of type long or ulong
// anything without is treated as int or uint depending on size.
// Ulong - Unsigned 64-bit integer
// (0 <= ulong <= 18,446,744,073,709,551,615)
ulong fooUlong = 100000L;
// Float - Single-precision 32-bit IEEE 754 Floating Point
// Precision: 7 digits
float fooFloat = 234.5f;
// f is used to denote that this variable value is of type float;
// otherwise it is treated as double.
// Double - Double-precision 64-bit IEEE 754 Floating Point // Double - Double-precision 64-bit IEEE 754 Floating Point
// Precision: 15-16 digits double fooDouble = 123.4; // Precision: 15-16 digits
double fooDouble = 123.4;
// Float - Single-precision 32-bit IEEE 754 Floating Point
float fooFloat = 234.5f; // Precision: 7 digits
// f is used to denote that this variable value is of type float
// Decimal - a 128-bits data type, with more precision than other floating-point types, // Decimal - a 128-bits data type, with more precision than other floating-point types,
// suited for financial and monetary calculations // suited for financial and monetary calculations
decimal fooDecimal = 150.3m; decimal fooDecimal = 150.3m;
// Boolean - true & false // Boolean - true & false
bool fooBoolean = true; bool fooBoolean = true; // or false
bool barBoolean = false;
// Char - A single 16-bit Unicode character // Char - A single 16-bit Unicode character
char fooChar = 'A'; char fooChar = 'A';
// Strings -- unlike the previous base types which are all value types, // Strings -- unlike the previous base types which are all value types,
// a string is a reference type. That is, you can set it to null // a string is a reference type. That is, you can set it to null
string fooString = "My string is here!"; string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
Console.WriteLine(fooString); Console.WriteLine(fooString);
// You can access each character of the string with an indexer: // You can access each character of the string with an indexer:
char charFromString = fooString[1]; // 'y' char charFromString = fooString[1]; // 'y'
// Strings are immutable: you can't do fooString[1] = 'X'; // Strings are immutable: you can't do fooString[1] = 'X';
// formatting // Compare strings with current culture, ignoring case
string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
Console.WriteLine(fooFormattedString);
// formatting dates // Formatting, based on sprintf
string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
// Dates & Formatting
DateTime fooDate = DateTime.Now; DateTime fooDate = DateTime.Now;
Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
// \n is an escaped character that starts a new line // You can split a string over two lines with the @ symbol. To escape " use ""
string barString = "Printing on a new line?\nNo Problem!";
Console.WriteLine(barString);
// it can be written prettier by using the @ symbol
string bazString = @"Here's some stuff string bazString = @"Here's some stuff
on a new line!"; on a new line! ""Wow!"", the masses cried";
Console.WriteLine(bazString);
// quotes need to be escaped
// use \" normally
string quotedString = "some \"quoted\" stuff";
Console.WriteLine(quotedString);
// use "" when strings start with @
string quotedString2 = @"some MORE ""quoted"" stuff";
Console.WriteLine(quotedString2);
// Use const or read-only to make a variable immutable // Use const or read-only to make a variable immutable
// const values are calculated at compile time // const values are calculated at compile time
const int HOURS_I_WORK_PER_WEEK = 9001; const int HOURS_I_WORK_PER_WEEK = 9001;
// Nullable types
// any value type (i.e. not a class) can be made nullable by suffixing a ?
// <type>? <var name> = <value>
int? nullable = null;
Console.WriteLine("Nullable variable: " + nullable);
// In order to use nullable's value, you have to use Value property
// or to explicitly cast it
DateTime? nullableDate = null;
// The previous line would not have compiled without the '?'
// because DateTime is a value type
// <type>? is equivalent to writing Nullable<type>
Nullable<DateTime> otherNullableDate = nullableDate;
nullableDate = DateTime.Now;
Console.WriteLine("Nullable value is: " + nullableDate.Value + " or: " + (DateTime) nullableDate );
// ?? is syntactic sugar for specifying default value
// in case variable is null
int notNullable = nullable ?? 0;
Console.WriteLine("Not nullable variable: " + notNullable);
// Var - compiler will choose the most appropriate type based on value
// Please note that this does not remove type safety.
// In this case, the type of fooImplicit is known to be a bool at compile time
var fooImplicit = true;
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
// Data Structures // Data Structures
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
Console.WriteLine("\n->Data Structures");
// Arrays // Arrays - zero indexed
// The array size must be decided upon declaration // The array size must be decided upon declaration
// The format for declaring an array is follows: // The format for declaring an array is follows:
// <datatype>[] <var name> = new <datatype>[<array size>]; // <datatype>[] <var name> = new <datatype>[<array size>];
int[] intArray = new int[10]; int[] intArray = new int[10];
string[] stringArray = new string[1];
bool[] boolArray = new bool[100];
// Another way to declare & initialize an array // Another way to declare & initialize an array
int[] y = { 9000, 1000, 1337 }; int[] y = { 9000, 1000, 1337 };
// Indexing an array - Accessing an element // Indexing an array - Accessing an element
Console.WriteLine("intArray @ 0: " + intArray[0]); Console.WriteLine("intArray @ 0: " + intArray[0]);
// Arrays are mutable.
// Arrays are zero-indexed and mutable.
intArray[1] = 1; intArray[1] = 1;
Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
// Lists // Lists
// Lists are used more frequently than arrays as they are more flexible // Lists are used more frequently than arrays as they are more flexible
@@ -202,28 +150,21 @@ namespace Learning
// List<datatype> <var name> = new List<datatype>(); // List<datatype> <var name> = new List<datatype>();
List<int> intList = new List<int>(); List<int> intList = new List<int>();
List<string> stringList = new List<string>(); List<string> stringList = new List<string>();
List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
// Another way to declare & initialize a list // The <> are for generics - Check out the cool stuff section
List<int> z = new List<int> { 9000, 1000, 1337 };
// Indexing a list - Accessing an element
// Lists are zero-indexed and mutable.
Console.WriteLine("z @ 0: " + z[2]);
// Lists don't default to a value; // Lists don't default to a value;
// A value must be added before accessing the index // A value must be added before accessing the index
intList.Add(1); intList.Add(1);
Console.WriteLine("intList @ 0: " + intList[0]); Console.WriteLine("intList @ 0: " + intList[0]);
// Others data structures to check out: // Others data structures to check out:
//
// Stack/Queue // Stack/Queue
// Dictionary (an implementation of a hash map) // Dictionary (an implementation of a hash map)
// HashSet
// Read-only Collections // Read-only Collections
// Tuple (.Net 4+) // Tuple (.Net 4+)
/////////////////////////////////////// ///////////////////////////////////////
// Operators // Operators
/////////////////////////////////////// ///////////////////////////////////////
@@ -232,10 +173,7 @@ namespace Learning
int i1 = 1, i2 = 2; // Shorthand for multiple declarations int i1 = 1, i2 = 2; // Shorthand for multiple declarations
// Arithmetic is straightforward // Arithmetic is straightforward
Console.WriteLine("1+2 = " + (i1 + i2)); // => 3 Console.WriteLine(i1 + i2 - i1 * 3 / 7); //
Console.WriteLine("2-1 = " + (i2 - i1)); // => 1
Console.WriteLine("2*1 = " + (i2 * i1)); // => 2
Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
// Modulo // Modulo
Console.WriteLine("11%3 = " + (11 % 3)); // => 2 Console.WriteLine("11%3 = " + (11 % 3)); // => 2
@@ -266,7 +204,6 @@ namespace Learning
Console.WriteLine(i--); //i = 1. Post-Decrementation Console.WriteLine(i--); //i = 1. Post-Decrementation
Console.WriteLine(--i); //i = 0. Pre-Decrementation Console.WriteLine(--i); //i = 0. Pre-Decrementation
/////////////////////////////////////// ///////////////////////////////////////
// Control Structures // Control Structures
/////////////////////////////////////// ///////////////////////////////////////
@@ -291,40 +228,28 @@ namespace Learning
// A simple if/else can be written as follows // A simple if/else can be written as follows
// <condition> ? <true> : <false> // <condition> ? <true> : <false>
string isTrue = (true) ? "True" : "False"; string isTrue = (true) ? "True" : "False";
Console.WriteLine("Ternary demo: " + isTrue);
// While loop // While loop
int fooWhile = 0; int fooWhile = 0;
while (fooWhile < 100) while (fooWhile < 100)
{ {
//Console.WriteLine(fooWhile);
//Increment the counter
//Iterated 99 times, fooWhile 0->99 //Iterated 99 times, fooWhile 0->99
fooWhile++; fooWhile++;
} }
Console.WriteLine("fooWhile Value: " + fooWhile);
// Do While Loop // Do While Loop
int fooDoWhile = 0; int fooDoWhile = 0;
do do
{ {
//Console.WriteLine(fooDoWhile);
//Increment the counter
//Iterated 99 times, fooDoWhile 0->99 //Iterated 99 times, fooDoWhile 0->99
fooDoWhile++; fooDoWhile++;
} while (fooDoWhile < 100); } while (fooDoWhile < 100);
Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
// For Loop
int fooFor;
//for loop structure => for(<start_statement>; <conditional>; <step>) //for loop structure => for(<start_statement>; <conditional>; <step>)
for (fooFor = 0; fooFor < 10; fooFor++) for (int fooFor = 0; fooFor < 10; fooFor++)
{ {
//Console.WriteLine(fooFor);
//Iterated 10 times, fooFor 0->9 //Iterated 10 times, fooFor 0->9
} }
Console.WriteLine("fooFor Value: " + fooFor);
// For Each Loop // For Each Loop
// foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>) // foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
@@ -334,7 +259,6 @@ namespace Learning
// (The ToCharArray() could be removed, because a string also implements IEnumerable) // (The ToCharArray() could be removed, because a string also implements IEnumerable)
foreach (char character in "Hello World".ToCharArray()) foreach (char character in "Hello World".ToCharArray())
{ {
//Console.WriteLine(character);
//Iterated over all the characters in the string //Iterated over all the characters in the string
} }
@@ -368,8 +292,6 @@ namespace Learning
monthString = "Some other month"; monthString = "Some other month";
break; break;
} }
Console.WriteLine("Switch Case Result: " + monthString);
/////////////////////////////////////// ///////////////////////////////////////
// Converting Data Types And Typecasting // Converting Data Types And Typecasting
@@ -384,46 +306,228 @@ namespace Learning
// try parse will default to type default on failure // try parse will default to type default on failure
// in this case: 0 // in this case: 0
int tryInt; int tryInt;
int.TryParse("123", out tryInt); if (int.TryParse("123", out tryInt)) // Funciton is boolean
Console.WriteLine(tryInt); // 123
// Convert Integer To String // Convert Integer To String
// Convert class has a number of methods to facilitate conversions // Convert class has a number of methods to facilitate conversions
Convert.ToString(123); Convert.ToString(123);
// or
tryInt.ToString();
}
/////////////////////////////////////// ///////////////////////////////////////
// Classes And Functions // CLASSES - see definitions at end of file
/////////////////////////////////////// ///////////////////////////////////////
public static void Classes()
Console.WriteLine("\n->Classes & Functions"); {
// See Declaration of objects at end of file
// (definition of the Bicycle class follows)
// Use new to instantiate a class // Use new to instantiate a class
Bicycle trek = new Bicycle(); Bicycle trek = new Bicycle();
// Call object methods // Call object methods
trek.speedUp(3); // You should always use setter and getter methods trek.SpeedUp(3); // You should always use setter and getter methods
trek.setCadence(100); trek.Cadence = 100;
// ToString is a convention to display the value of this Object. // ToString is a convention to display the value of this Object.
Console.WriteLine("trek info: " + trek.ToString()); Console.WriteLine("trek info: " + trek.Info());
// Instantiate another new Bicycle
Bicycle octo = new Bicycle(5, 10);
Console.WriteLine("octo info: " + octo.ToString());
// Instantiate a new Penny Farthing // Instantiate a new Penny Farthing
PennyFarthing funbike = new PennyFarthing(1, 10); PennyFarthing funbike = new PennyFarthing(1, 10);
Console.WriteLine("funbike info: " + funbike.ToString()); Console.WriteLine("funbike info: " + funbike.Info());
Console.Read(); Console.Read();
} // End main method } // End main method
// CONSOLE ENTRY A console application must have a main method as an entry point
public static void Main(string[] args)
{
OtherInterestingFeatures();
}
//
// INTERESTING FEATURES
//
// DEFAULT METHOD SIGNATURES
public // Visibility
static // Allows for direct call on class without object
int // Return Type,
MethodSignatures(
int maxCount, // First variable, expects an int
int count = 0, // will default the value to 0 if not passed in
int another = 3,
params string[] otherParams // captures all other parameters passed to method
)
{
return -1;
}
// Methods can have the same name, as long as the signature is unique
public static void MethodSignature(string maxCount)
{
}
// GENERICS
// The classes for TKey and TValue is specified by the user calling this function.
// This method emulates the SetDefault of Python
public static TValue SetDefault<TKey, TValue>(
IDictionary<TKey, TValue> dictionary,
TKey key,
TValue defaultItem)
{
TValue result;
if (!dictionary.TryGetValue(key, out result))
return dictionary[key] = defaultItem;
return result;
}
// You can narrow down the objects that are passed in
public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
{
// We can iterate, since T is a IEnumerable
foreach (var item in toPrint)
// Item is an int
Console.WriteLine(item.ToString());
}
public static void OtherInterestingFeatures()
{
// OPTIONAL PARAMETERS
MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
// EXTENSION METHODS
int i = 3;
i.Print(); // Defined below
// NULLABLE TYPES - great for database interaction / return values
// any value type (i.e. not a class) can be made nullable by suffixing a ?
// <type>? <var name> = <value>
int? nullable = null; // short hand for Nullable<int>
Console.WriteLine("Nullable variable: " + nullable);
bool hasValue = nullable.HasValue; // true if not null
// ?? is syntactic sugar for specifying default value (coalesce)
// in case variable is null
int notNullable = nullable ?? 0; // 0
// IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
var magic = "magic is a string, at compile time, so you still get type safety";
// magic = 9; will not work as magic is a string, not an int
// GENERICS
//
var phonebook = new Dictionary<string, string>() {
{"Sarah", "212 555 5555"} // Add some entries to the phone book
};
// Calling SETDEFAULT defined as a generic above
Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
// nb, you don't need to specify the TKey and TValue since they can be
// derived implicitly
Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
// LAMBDA EXPRESSIONS - allow you to write code in line
Func<int, int> square = (x) => x * x; // Last T item is the return value
Console.WriteLine(square(3)); // 9
// PARALLEL FRAMEWORK
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
var websites = new string[] {
"http://www.google.com", "http://www.reddit.com",
"http://www.shaunmccarthy.com"
};
var responses = new Dictionary<string, string>();
// Will spin up separate threads for each request, and join on them
// before going to the next step!
Parallel.ForEach(websites,
new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
website =>
{
// Do something that takes a long time on the file
using (var r = WebRequest.Create(new Uri(website)).GetResponse())
{
responses[website] = r.ContentType;
}
});
// This won't happen till after all requests have been completed
foreach (var key in responses.Keys)
Console.WriteLine("{0}:{1}", key, responses[key]);
// DYNAMIC OBJECTS (great for working with other languages)
dynamic student = new ExpandoObject();
student.FirstName = "First Name"; // No need to define class first!
// You can even add methods (returns a string, and takes in a string)
student.Introduce = new Func<string, string>(
(introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
Console.WriteLine(student.Introduce("Beth"));
// IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
// very useful Map / Filter / Reduce style methods
var bikes = new List<Bicycle>();
bikes.Sort(); // Sorts the array
bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
var result = bikes
.Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
.Where(b => b.IsBroken && b.HasTassles)
.Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
// Create a list of IMPLICIT objects based on some parameters of the bike
var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
// Hard to show here, but you get type ahead completion since the compiler can implicitly work
// out the types above!
foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
Console.WriteLine(bikeSummary.Name);
// ASPARALLEL
// And this is where things get wicked - combines linq and parallel operations
var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
// this will happen in parallel! Threads will automagically be spun up and the
// results divvied amongst them! Amazing for large datasets when you have lots of
// cores
// LINQ - maps a store to IQueryable<T> objects, with delayed execution
// e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
var db = new BikeRespository();
// execution is delayed, which is great when querying a database
var fitler = db.Bikes.Where(b => b.HasTassles); // no query run
if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
fitler = fitler.Where(b => b.IsBroken); // no query run
var query = fitler
.OrderBy(b => b.Wheels)
.ThenBy(b => b.Name)
.Select(b => b.Name); // still no query run
// Now the query runs, but opens a reader, so only populates are you iterate through
foreach (string bike in query)
Console.WriteLine(result);
}
} // End LearnCSharp class } // End LearnCSharp class
// You can include other classes in a .cs file // You can include other classes in a .cs file
public static class Extensions
{
// EXTENSION FUNCTIONS
public static void Print(this object obj)
{
Console.WriteLine(obj.ToString());
}
}
// Class Declaration Syntax: // Class Declaration Syntax:
// <public/private/protected/internal> class <class name>{ // <public/private/protected/internal> class <class name>{
@@ -434,64 +538,88 @@ namespace Learning
public class Bicycle public class Bicycle
{ {
// Bicycle's Fields/Variables // Bicycle's Fields/Variables
public int cadence; // Public: Can be accessed from anywhere public int Cadence // Public: Can be accessed from anywhere
private int _speed; // Private: Only accessible from within the class {
protected int gear; // Protected: Accessible from the class and subclasses get // get - define a method to retrieve the property
internal int wheels; // Internal: Accessible from within the assembly {
string name; // Everything is private by default: Only accessible from within this class return _cadence;
}
set // set - define a method to set a proprety
{
_cadence = value; // Value is the value passed in to to the setter
}
}
private int _cadence;
protected virtual int Gear // Protected: Accessible from the class and subclasses
{
get; // creates an auto property so you don't need a member field
set;
}
internal int Wheels // Internal: Accessible from within the assembly
{
get;
private set; // You can set modifiers on the get/set methods
}
int _speed; // Everything is private by default: Only accessible from within this class.
// can also use keyword privatee
public string Name { get; set; }
// Enum is a value type that consists of a set of named constants // Enum is a value type that consists of a set of named constants
// It is really just mapping a name to a value (an int, unless specified otherwise). // It is really just mapping a name to a value (an int, unless specified otherwise).
// The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong. // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
// An enum can't contain the same value twice. // An enum can't contain the same value twice.
public enum Brand public enum BikeBrand
{ {
AIST, AIST,
BMC, BMC,
Electra=42, //you can explicitly set a value to a name Electra = 42, //you can explicitly set a value to a name
Gitane Gitane
} }
// We defined this type inside a Bicycle class, so it is a nested type // We defined this type inside a Bicycle class, so it is a nested type
// Code outside of this class should reference this type as Bicycle.Brand // Code outside of this class should reference this type as Bicycle.Brand
public Brand brand; // After declaring an enum type, we can declare the field of this type public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
// Static members belong to the type itself rather then specific object. // Static members belong to the type itself rather then specific object.
static public int bicyclesCreated = 0;
// You can access them without a reference to any object: // You can access them without a reference to any object:
// Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
static public int BicyclesCreated = 0;
// readonly values are set at run time // readonly values are set at run time
// they can only be assigned upon declaration or in a constructor // they can only be assigned upon declaration or in a constructor
readonly bool hasCardsInSpokes = false; // read-only private readonly bool _hasCardsInSpokes = false; // read-only private
// Constructors are a way of creating classes // Constructors are a way of creating classes
// This is a default constructor // This is a default constructor
private Bicycle() public Bicycle()
{ {
gear = 1; this.Gear = 1; // you can access mmebers of the object with the keyword this
cadence = 50; Cadence = 50; // but you don't always need it
_speed = 5; _speed = 5;
name = "Bontrager"; Name = "Bontrager";
brand = Brand.AIST; Brand = BikeBrand.AIST;
bicyclesCreated++; BicyclesCreated++;
} }
// This is a specified constructor (it contains arguments) // This is a specified constructor (it contains arguments)
public Bicycle(int startCadence, int startSpeed, int startGear, public Bicycle(int startCadence, int startSpeed, int startGear,
string name, bool hasCardsInSpokes, Brand brand) string name, bool hasCardsInSpokes, BikeBrand brand)
: base() // calls base first
{ {
this.gear = startGear; // "this" keyword denotes the current object Gear = startGear;
this.cadence = startCadence; Cadence = startCadence;
this._speed = startSpeed; _speed = startSpeed;
this.name = name; // it can be useful when there's a name conflict Name = name;
this.hasCardsInSpokes = hasCardsInSpokes; _hasCardsInSpokes = hasCardsInSpokes;
this.brand = brand; Brand = brand;
} }
// Constructors can be chained // Constructors can be chained
public Bicycle(int startCadence, int startSpeed, Brand brand) : public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
this(startCadence, startSpeed, 0, "big wheels", true) this(startCadence, startSpeed, 0, "big wheels", true, brand)
{ {
} }
@@ -501,25 +629,6 @@ namespace Learning
// classes can implement getters and setters for their fields // classes can implement getters and setters for their fields
// or they can implement properties (this is the preferred way in C#) // or they can implement properties (this is the preferred way in C#)
// Method declaration syntax:
// <scope> <return type> <method name>(<args>)
public int GetCadence()
{
return cadence;
}
// void methods require no return statement
public void SetCadence(int newValue)
{
cadence = newValue;
}
// virtual keyword indicates this method can be overridden in a derived class
public virtual void SetGear(int newValue)
{
gear = newValue;
}
// Method parameters can have default values. // Method parameters can have default values.
// In this case, methods can be called with these parameters omitted // In this case, methods can be called with these parameters omitted
public void SpeedUp(int increment = 1) public void SpeedUp(int increment = 1)
@@ -558,13 +667,13 @@ namespace Learning
} }
//Method to display the attribute values of this Object. //Method to display the attribute values of this Object.
public override string ToString() public virtual string Info()
{ {
return "gear: " + gear + return "Gear: " + Gear +
" cadence: " + cadence + " Cadence: " + Cadence +
" speed: " + _speed + " Speed: " + _speed +
" name: " + name + " Name: " + Name +
" cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
"\n------------------------------\n" "\n------------------------------\n"
; ;
} }
@@ -573,9 +682,10 @@ namespace Learning
public static bool DidWeCreateEnoughBycles() public static bool DidWeCreateEnoughBycles()
{ {
// Within a static method, we only can reference static class members // Within a static method, we only can reference static class members
return bicyclesCreated > 9000; return BicyclesCreated > 9000;
} // If your class only needs static members, consider marking the class itself as static. } // If your class only needs static members, consider marking the class itself as static.
} // end class Bicycle } // end class Bicycle
// PennyFarthing is a subclass of Bicycle // PennyFarthing is a subclass of Bicycle
@@ -586,20 +696,27 @@ namespace Learning
// calling parent constructor // calling parent constructor
public PennyFarthing(int startCadence, int startSpeed) : public PennyFarthing(int startCadence, int startSpeed) :
base(startCadence, startSpeed, 0, "PennyFarthing", true) base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
{ {
} }
public override void SetGear(int gear) protected override int Gear
{ {
gear = 0; get
{
return 0;
}
set
{
throw new ArgumentException("You can't change gears on a PennyFarthing");
}
} }
public override string ToString() public override string Info()
{ {
string result = "PennyFarthing bicycle "; string result = "PennyFarthing bicycle ";
result += base.ToString(); // Calling the base version of the method result += base.ToString(); // Calling the base version of the method
return reuslt; return result;
} }
} }
@@ -624,7 +741,7 @@ namespace Learning
damage += meters; damage += meters;
} }
public void Broken public bool Broken
{ {
get get
{ {
@@ -632,24 +749,34 @@ namespace Learning
} }
} }
} }
} // End Namespace
/// <summary>
/// Used to connect to DB for LinqToSql example.
/// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary>
public class BikeRespository : DbSet
{
public BikeRespository()
: base()
{
}
public DbSet<Bicycle> Bikes { get; set; }
}
} // End Namespace
``` ```
## Topics Not Covered ## Topics Not Covered
* Flags * Flags
* Attributes * Attributes
* Generics (T), Delegates, Func, Actions, lambda expressions
* Static properties * Static properties
* Exceptions, Abstraction * Exceptions, Abstraction
* LINQ
* ASP.NET (Web Forms/MVC/WebMatrix) * ASP.NET (Web Forms/MVC/WebMatrix)
* Winforms * Winforms
* Windows Presentation Foundation (WPF) * Windows Presentation Foundation (WPF)
## Further Reading ## Further Reading
* [DotNetPerls](http://www.dotnetperls.com) * [DotNetPerls](http://www.dotnetperls.com)

4
es-es/coffeescript-es.html.markdown
View File

@@ -44,7 +44,7 @@ math =
# "cube": function(x) { return x * square(x); } # "cube": function(x) { return x * square(x); }
#} #}
# Símbolos: # Número de argumentos variable:
race = (winner, runners...) -> race = (winner, runners...) ->
print winner, runners print winner, runners
@@ -52,6 +52,6 @@ race = (winner, runners...) ->
alert "I knew it!" if elvis? alert "I knew it!" if elvis?
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
# Colecciones por comprensión: # Listas:
cubes = (math.cube num for num in list) #=> ... cubes = (math.cube num for num in list) #=> ...
``` ```

4
fr-fr/python-fr.html.markdown
View File

@@ -156,9 +156,9 @@ li[4] # Lève un 'IndexError'
# On peut accèder à des rangs de valeurs avec la syntaxe "slice" # On peut accèder à des rangs de valeurs avec la syntaxe "slice"
# (C'est un rang de type 'fermé/ouvert' pour les plus matheux) # (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
li[1:3] #=> [2, 4] li[1:3] #=> [2, 4]
# Sans spécifier de début de rang # Sans spécifier de fin de rang, on "saute" le début de la liste
li[2:] #=> [4, 3] li[2:] #=> [4, 3]
# Sans spécifier de fin de rang # Sans spécifier de début de rang, on "saute" la fin de la liste
li[:3] #=> [1, 2, 4] li[:3] #=> [1, 2, 4]
# Retirer un élément spécifique dee la liste avec "del" # Retirer un élément spécifique dee la liste avec "del"

2
haskell.html.markdown
View File

@@ -11,7 +11,7 @@ makes coding a real joy for me.
```haskell ```haskell
-- Single line comments start with two dashes. -- Single line comments start with two dashes.
{- Multiline comments can be enclosed {- Multiline comments can be enclosed
en a block like this. in a block like this.
-} -}
---------------------------------------------------- ----------------------------------------------------

305
julia.html.markdown
View File

@@ -8,7 +8,7 @@ filename: learnjulia.jl
Julia is a new homoiconic functional language focused on technical computing. Julia is a new homoiconic functional language focused on technical computing.
While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python. While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
This is based on the current development version of Julia, as of June 29th, 2013. This is based on the current development version of Julia, as of October 18th, 2013.
```ruby ```ruby
@@ -20,20 +20,20 @@ This is based on the current development version of Julia, as of June 29th, 2013
# Everything in Julia is a expression. # Everything in Julia is a expression.
# You have numbers # There are several basic types of numbers.
3 #=> 3 (Int64) 3 #=> 3 (Int64)
3.2 #=> 3.2 (Float64) 3.2 #=> 3.2 (Float64)
2 + 1im #=> 2 + 1im (Complex{Int64}) 2 + 1im #=> 2 + 1im (Complex{Int64})
2//3 #=> 2//3 (Rational{Int64}) 2//3 #=> 2//3 (Rational{Int64})
# Math is what you would expect # All of the normal infix operators are available.
1 + 1 #=> 2 1 + 1 #=> 2
8 - 1 #=> 7 8 - 1 #=> 7
10 * 2 #=> 20 10 * 2 #=> 20
35 / 5 #=> 7.0 35 / 5 #=> 7.0
5 / 2 #=> 2.5 # dividing an Int by an Int always results in a Float
div(5, 2) #=> 2 # for a truncated result, use div
5 \ 35 #=> 7.0 5 \ 35 #=> 7.0
5 / 2 #=> 2.5
div(5, 2) #=> 2
2 ^ 2 #=> 4 # power, not bitwise xor 2 ^ 2 #=> 4 # power, not bitwise xor
12 % 10 #=> 2 12 % 10 #=> 2
@@ -77,11 +77,13 @@ false
# Strings are created with " # Strings are created with "
"This is a string." "This is a string."
# Character literals written with ' # Character literals are written with '
'a' 'a'
# A string can be treated like a list of characters # A string can be indexed like an array of characters
"This is a string"[1] #=> 'T' # Julia indexes from 1 "This is a string"[1] #=> 'T' # Julia indexes from 1
# However, this is will not work well for UTF8 strings,
# so iterating over strings is reccommended (map, for loops, etc).
# $ can be used for string interpolation: # $ can be used for string interpolation:
"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" "2 + 2 = $(2 + 2)" #=> "2 + 2 = 4"
@@ -94,10 +96,10 @@ false
## 2. Variables and Collections ## 2. Variables and Collections
#################################################### ####################################################
# Printing is pretty easy # Printing is easy
println("I'm Julia. Nice to meet you!") println("I'm Julia. Nice to meet you!")
# No need to declare variables before assigning to them. # You don't declare variables before assigning to them.
some_var = 5 #=> 5 some_var = 5 #=> 5
some_var #=> 5 some_var #=> 5
@@ -108,12 +110,14 @@ catch e
println(e) println(e)
end end
# Variable name start with a letter. You can use uppercase letters, digits, # Variable names start with a letter.
# and exclamation points as well after the initial alphabetic character. # After that, you can use letters, digits, underscores, and exclamation points.
SomeOtherVar123! = 6 #=> 6 SomeOtherVar123! = 6 #=> 6
# You can also use unicode characters # You can also use unicode characters
☃ = 8 #=> 8 ☃ = 8 #=> 8
# These are especially handy for mathematical notation
2 * π #=> 6.283185307179586
# A note on naming conventions in Julia: # A note on naming conventions in Julia:
# #
@@ -158,6 +162,10 @@ a[1] #=> 1 # remember that Julia indexes from 1, not 0!
# indexing expression # indexing expression
a[end] #=> 6 a[end] #=> 6
# we also have shift and unshift
shift!(a) #=> 1 and a is now [2,4,3,4,5,6]
unshift!(a,7) #=> [7,2,4,3,4,5,6]
# Function names that end in exclamations points indicate that they modify # Function names that end in exclamations points indicate that they modify
# their argument. # their argument.
arr = [5,4,6] #=> 3-element Int64 Array: [5,4,6] arr = [5,4,6] #=> 3-element Int64 Array: [5,4,6]
@@ -182,23 +190,24 @@ a = [1:5] #=> 5-element Int64 Array: [1,2,3,4,5]
# You can look at ranges with slice syntax. # You can look at ranges with slice syntax.
a[1:3] #=> [1, 2, 3] a[1:3] #=> [1, 2, 3]
a[2:] #=> [2, 3, 4, 5] a[2:] #=> [2, 3, 4, 5]
a[2:end] #=> [2, 3, 4, 5]
# Remove arbitrary elements from a list with splice! # Remove elements from an array by index with splice!
arr = [3,4,5] arr = [3,4,5]
splice!(arr,2) #=> 4 ; arr is now [3,5] splice!(arr,2) #=> 4 ; arr is now [3,5]
# Concatenate lists with append! # Concatenate lists with append!
b = [1,2,3] b = [1,2,3]
append!(a,b) # Now a is [1, 3, 4, 5, 1, 2, 3] append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3]
# Check for existence in a list with contains # Check for existence in a list with in
contains(a,1) #=> true in(a,1) #=> true
# Examine the length with length # Examine the length with length
length(a) #=> 7 length(a) #=> 8
# Tuples are immutable. # Tuples are immutable.
tup = (1, 2, 3) #=>(1,2,3) # an (Int64,Int64,Int64) tuple. tup = (1, 2, 3) #=> (1,2,3) # an (Int64,Int64,Int64) tuple.
tup[1] #=> 1 tup[1] #=> 1
try: try:
tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
@@ -209,22 +218,26 @@ end
# Many list functions also work on tuples # Many list functions also work on tuples
length(tup) #=> 3 length(tup) #=> 3
tup[1:2] #=> (1,2) tup[1:2] #=> (1,2)
contains(tup,2) #=> true in(tup,2) #=> true
# You can unpack tuples into variables # You can unpack tuples into variables
a, b, c = (1, 2, 3) #=> (1,2,3) # a is now 1, b is now 2 and c is now 3 a, b, c = (1, 2, 3) #=> (1,2,3) # a is now 1, b is now 2 and c is now 3
# Tuples are created by default if you leave out the parentheses # Tuples are created even if you leave out the parentheses
d, e, f = 4, 5, 6 #=> (4,5,6) d, e, f = 4, 5, 6 #=> (4,5,6)
# Now look how easy it is to swap two values # A 1-element tuple is distinct from the value it contains
(1,) == 1 #=> false
(1) == 1 #=> true
# Look how easy it is to swap two values
e, d = d, e #=> (5,4) # d is now 5 and e is now 4 e, d = d, e #=> (5,4) # d is now 5 and e is now 4
# Dictionaries store mappings # Dictionaries store mappings
empty_dict = Dict() #=> Dict{Any,Any}() empty_dict = Dict() #=> Dict{Any,Any}()
# Here is a prefilled dictionary # You can create a dictionary using a literal
filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
# => Dict{ASCIIString,Int64} # => Dict{ASCIIString,Int64}
@@ -241,31 +254,35 @@ values(filled_dict)
#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) #=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
# Note - Same as above regarding key ordering. # Note - Same as above regarding key ordering.
# Check for existence of keys in a dictionary with contains, haskey # Check for existence of keys in a dictionary with in, haskey
contains(filled_dict, ("one", 1)) #=> true in(filled_dict, ("one", 1)) #=> true
contains(filled_dict, ("two", 3)) #=> false in(filled_dict, ("two", 3)) #=> false
haskey(filled_dict, "one") #=> true haskey(filled_dict, "one") #=> true
haskey(filled_dict, 1) #=> false haskey(filled_dict, 1) #=> false
# Trying to look up a non-existing key will raise an error # Trying to look up a non-existant key will raise an error
try try
filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489 filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489
catch e catch e
println(e) println(e)
end end
# Use get method to avoid the error # Use the get method to avoid that error by providing a default value
# get(dictionary,key,default_value) # get(dictionary,key,default_value)
get(filled_dict,"one",4) #=> 1 get(filled_dict,"one",4) #=> 1
get(filled_dict,"four",4) #=> 4 get(filled_dict,"four",4) #=> 4
# Sets store sets # Use Sets to represent collections of unordered, unique values
empty_set = Set() #=> Set{Any}() empty_set = Set() #=> Set{Any}()
# Initialize a set with a bunch of values # Initialize a set with values
filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4)
# Add more items to a set # Add more values to a set
add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1)
# Check if the values are in the set
in(filled_set,2) #=> true
in(filled_set,10) #=> false
# There are functions for set intersection, union, and difference. # There are functions for set intersection, union, and difference.
other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3) other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3)
@@ -273,10 +290,6 @@ intersect(filled_set, other_set) #=> Set{Int64}(3,4,5)
union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6) union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6)
setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4) setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4)
# Check for existence in a set with contains
contains(filled_set,2) #=> true
contains(filled_set,10) #=> false
#################################################### ####################################################
## 3. Control Flow ## 3. Control Flow
@@ -285,8 +298,7 @@ contains(filled_set,10) #=> false
# Let's make a variable # Let's make a variable
some_var = 5 some_var = 5
# Here is an if statement. Indentation is NOT meaningful in Julia. # Here is an if statement. Indentation is not meaningful in Julia.
# prints "some var is smaller than 10"
if some_var > 10 if some_var > 10
println("some_var is totally bigger than 10.") println("some_var is totally bigger than 10.")
elseif some_var < 10 # This elseif clause is optional. elseif some_var < 10 # This elseif clause is optional.
@@ -294,12 +306,22 @@ elseif some_var < 10 # This elseif clause is optional.
else # The else clause is optional too. else # The else clause is optional too.
println("some_var is indeed 10.") println("some_var is indeed 10.")
end end
#=> prints "some var is smaller than 10"
# For loops iterate over iterables, such as ranges, lists, sets, dicts, strings. # For loops iterate over iterables.
# Iterable types include Range, Array, Set, Dict, and String.
for animal=["dog", "cat", "mouse"] for animal=["dog", "cat", "mouse"]
# You can use $ to interpolate into strings println("$animal is a mammal")
# You can use $ to interpolate variables or expression into strings
end
# prints:
# dog is a mammal
# cat is a mammal
# mouse is a mammal
# You can use 'in' instead of '='.
for animal in ["dog", "cat", "mouse"]
println("$animal is a mammal") println("$animal is a mammal")
end end
# prints: # prints:
@@ -307,31 +329,33 @@ end
# cat is a mammal # cat is a mammal
# mouse is a mammal # mouse is a mammal
# You can use in instead of =, if you want.
for animal in ["dog", "cat", "mouse"]
println("$animal is a mammal")
end
for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
println("$(a[1]) is $(a[2])") println("$(a[1]) is a $(a[2])")
end end
# prints:
# dog is a mammal
# cat is a mammal
# mouse is a mammal
for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
println("$k is $v") println("$k is a $v")
end end
# While loops go until a condition is no longer met.
# prints: # prints:
# 0 # dog is a mammal
# 1 # cat is a mammal
# 2 # mouse is a mammal
# 3
# While loops loop while a condition is true
x = 0 x = 0
while x < 4 while x < 4
println(x) println(x)
x += 1 # Shorthand for x = x + 1 x += 1 # Shorthand for x = x + 1
end end
# prints:
# 0
# 1
# 2
# 3
# Handle exceptions with a try/except block # Handle exceptions with a try/except block
try try
@@ -346,11 +370,14 @@ end
## 4. Functions ## 4. Functions
#################################################### ####################################################
# Use the keyword function to create new functions # The keyword 'function' creates new functions
#function name(arglist)
# body...
#end
function add(x, y) function add(x, y)
println("x is $x and y is $y") println("x is $x and y is $y")
# Functions implicitly return the value of their last statement # Functions return the value of their last statement
x + y x + y
end end
@@ -360,13 +387,16 @@ add(5, 6) #=> 11 after printing out "x is 5 and y is 6"
# positional arguments # positional arguments
function varargs(args...) function varargs(args...)
return args return args
# use the keyword return to return anywhere in the function
end end
#=> varargs (generic function with 1 method)
varargs(1,2,3) #=> (1,2,3) varargs(1,2,3) #=> (1,2,3)
# The ... is called a splat. # The ... is called a splat.
# It can also be used in a fuction call # We just used it in a function definition.
# to splat a list or tuple out to be the arguments # It can also be used in a fuction call,
# where it will splat an Array or Tuple's contents into the argument list.
Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
Set([1,2,3]...) #=> Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3) Set([1,2,3]...) #=> Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
@@ -399,7 +429,7 @@ keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4]
keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"]
keyword_args() #=> ["name2"=>"hello","k2"=>4] keyword_args() #=> ["name2"=>"hello","k2"=>4]
# You can also do both at once # You can combine all kinds of arguments in the same function
function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
println("normal arg: $normal_arg") println("normal arg: $normal_arg")
println("optional arg: $optional_positional_arg") println("optional arg: $optional_positional_arg")
@@ -420,12 +450,15 @@ function create_adder(x)
return adder return adder
end end
# or equivalently # This is "stabby lambda syntax" for creating anonymous functions
(x -> x > 2)(3) #=> true
# This function is identical to create_adder implementation above.
function create_adder(x) function create_adder(x)
y -> x + y y -> x + y
end end
# you can also name the internal function, if you want # You can also name the internal function, if you want
function create_adder(x) function create_adder(x)
function adder(y) function adder(y)
x + y x + y
@@ -436,61 +469,114 @@ end
add_10 = create_adder(10) add_10 = create_adder(10)
add_10(3) #=> 13 add_10(3) #=> 13
# The first two inner functions above are anonymous functions
(x -> x > 2)(3) #=> true
# There are built-in higher order functions # There are built-in higher order functions
map(add_10, [1,2,3]) #=> [11, 12, 13] map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# We can use list comprehensions for nice maps and filters # We can use list comprehensions for nicer maps
[add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13] [add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13]
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] [add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
#################################################### ####################################################
## 5. Types and Multiple-Dispatch ## 5. Types
#################################################### ####################################################
# Type definition # Julia has a type system.
# Every value has a type; variables do not have types themselves.
# You can use the `typeof` function to get the type of a value.
typeof(5) #=> Int64
# Types are first-class values
typeof(Int64) #=> DataType
typeof(DataType) #=> DataType
# DataType is the type that represents types, including itself.
# Types are used for documentation, optimizations, and dispatch.
# They are not statically checked.
# Users can define types
# They are like records or structs in other languages.
# New types are defined used the `type` keyword.
# type Name
# field::OptionalType
# ...
# end
type Tiger type Tiger
taillength::Float64 taillength::Float64
coatcolor # no type annotation is implicitly Any coatcolor # not including a type annotation is the same as `::Any`
end end
# default constructor is the properties in order
# so, Tiger(taillength,coatcolor)
# Type instantiation # The default constructor's arguments are the properties
tigger = Tiger(3.5,"orange") # the type doubles as the constructor function # of the tyep, in order the order they are listed in the definition
tigger = Tiger(3.5,"orange") #=> Tiger(3.5,"orange")
# Abtract Types # The type doubles as the constructor function for values of that type
sherekhan = typeof(tigger)(5.6,"fire") #=> Tiger(5.6,"fire")
# These struct-style types are called concrete types
# They can be instantiated, but cannot have subtypes.
# The other kind of types is abstract types.
# abstract Name
abstract Cat # just a name and point in the type hierarchy abstract Cat # just a name and point in the type hierarchy
# * types defined with the type keyword are concrete types; they can be # Abstract types cannot be instantiated, but can have subtypes.
# instantiated # For example, Number is an abstract type
# subtypes(Number) #=> 6-element Array{Any,1}:
# * types defined with the abstract keyword are abstract types; they can # Complex{Float16}
# have subtypes. # Complex{Float32}
# # Complex{Float64}
# * each type has one supertype; a supertype can have zero or more subtypes. # Complex{T<:Real}
# ImaginaryUnit
# Real
subtypes(Cat) #=> 0-element Array{Any,1}
# Every type has a super type; use the `super` function to get it.
typeof(5) #=> Int64
super(Int64) #=> Signed
super(Signed) #=> Real
super(Real) #=> Number
super(Number) #=> Any
super(super(Signed)) #=> Number
super(Any) #=> Any
# All of these type, except for Int64, are abstract.
# <: is the subtyping operator
type Lion <: Cat # Lion is a subtype of Cat type Lion <: Cat # Lion is a subtype of Cat
mane_color mane_color
roar::String roar::String
end end
# You can define more constructors for your type
# Just define a function of the same name as the type
# and call an existing constructor to get a value of the correct type
Lion(roar::String) = Lion("green",roar)
# This is an outer constructor because it's outside the type definition
type Panther <: Cat # Panther is also a subtype of Cat type Panther <: Cat # Panther is also a subtype of Cat
eye_color eye_color
Panther() = new("green") Panther() = new("green")
# Panthers will only have this constructor, and no default constructor. # Panthers will only have this constructor, and no default constructor.
end end
# Using inner constructors, like Panter does, gives you control
# over how values of the type can be created.
# When possible, you should use outer constructors rather than inner ones.
# Multiple Dispatch ####################################################
## 6. Multiple-Dispatch
####################################################
# In Julia, all named functions are generic functions # In Julia, all named functions are generic functions
# This means that they are built up from many small methods # This means that they are built up from many small methods
# For example, let's make a function meow: # Each constructor for Lion is a method of the generic function Lion.
# For a non-constructor example, let's make a function meow:
# Definitions for Lion, Panther, Tiger
function meow(cat::Lion) function meow(cat::Lion)
cat.roar # access properties using dot notation cat.roar # access type properties using dot notation
end end
function meow(cat::Panther) function meow(cat::Panther)
@@ -501,21 +587,75 @@ function meow(cat::Tiger)
"rawwwr" "rawwwr"
end end
# Testing the meow function
meow(tigger) #=> "rawwr" meow(tigger) #=> "rawwr"
meow(Lion("brown","ROAAR")) #=> "ROAAR" meow(Lion("brown","ROAAR")) #=> "ROAAR"
meow(Panther()) #=> "grrr" meow(Panther()) #=> "grrr"
# Review the local type hierarchy
issubtype(Tiger,Cat) #=> false
issubtype(Lion,Cat) #=> true
issubtype(Panther,Cat) #=> true
# Defining a function that takes Cats
function pet_cat(cat::Cat) function pet_cat(cat::Cat)
println("The cat says $(meow(cat))") println("The cat says $(meow(cat))")
end end
pet_cat(Lion("42")) #=> prints "The cat says 42"
try try
pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,) pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,)
catch e catch e
println(e) println(e)
end end
pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42" # In OO languages, single dispatch is common;
# this means that the method is picked based on the type of the first argument.
# In Julia, all of the argument types contribute to selecting the best method.
# Let's define a function with more arguments, so we can see the difference
function fight(t::Tiger,c::Cat)
println("The $(t.coatcolor) tiger wins!")
end
#=> fight (generic function with 1 method)
fight(tigger,Panther()) #=> prints The orange tiger wins!
fight(tigger,Lion("ROAR")) #=> prints The orange tiger wins!
# Let's change the behavior when the Cat is specifically a Lion
fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
#=> fight (generic function with 2 methods)
fight(tigger,Panther()) #=> prints The orange tiger wins!
fight(tigger,Lion("ROAR")) #=> prints The green-maned lion wins!
# We don't need a Tiger in order to fight
fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
#=> fight (generic function with 3 methods)
fight(Lion("balooga!"),Panther()) #=> prints The victorious cat says grrr
try
fight(Panther(),Lion("RAWR")) #=> ERROR: no method fight(Panther,Lion)
catch
end
# Also let the cat go first
fight(c::Cat,l::Lion) = println("The cat beats the Lion")
#=> Warning: New definition
# fight(Cat,Lion) at none:1
# is ambiguous with
# fight(Lion,Cat) at none:2.
# Make sure
# fight(Lion,Lion)
# is defined first.
#fight (generic function with 4 methods)
# This warning is because it's unclear which fight will be called in:
fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The victorious cat says rarrr
# The result may be different in other versions of Julia
fight(l::Lion,l2::Lion) = println("The lions come to a tie")
fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The lions come to a tie
``` ```
@@ -523,3 +663,4 @@ pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42"
You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/) You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).