mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Merged with latest from upstream
This commit is contained in:
Adam
commit
dadd4c2a2b
@ -117,7 +117,7 @@ done
|
||||
|
||||
# You can also define functions
|
||||
# Definition:
|
||||
foo ()
|
||||
function foo ()
|
||||
{
|
||||
echo "Arguments work just like script arguments: $@"
|
||||
echo "And: $1 $2..."
|
||||
@ -125,6 +125,13 @@ foo ()
|
||||
return 0
|
||||
}
|
||||
|
||||
# or simply
|
||||
bar ()
|
||||
{
|
||||
echo "Another way to declare functions!"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Calling your function
|
||||
foo "My name is" $NAME
|
||||
|
||||
|
||||
@ -4,6 +4,7 @@ contributors:
|
||||
- ["Irfan Charania", "https://github.com/irfancharania"]
|
||||
- ["Max Yankov", "https://github.com/golergka"]
|
||||
- ["Melvyn Laïly", "http://x2a.yt"]
|
||||
- ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
|
||||
filename: LearnCSharp.cs
|
||||
---
|
||||
|
||||
@ -23,7 +24,12 @@ Multi-line comments look like this
|
||||
// Specify namespaces application will be using
|
||||
using System;
|
||||
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"
|
||||
namespace Learning
|
||||
@ -32,8 +38,8 @@ namespace Learning
|
||||
// you're allowed to do otherwise, but shouldn't for sanity.
|
||||
public class LearnCSharp
|
||||
{
|
||||
// A console application must have a main method as an entry point
|
||||
public static void Main(string[] args)
|
||||
// BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
|
||||
public static void Syntax()
|
||||
{
|
||||
// Use Console.WriteLine to print lines
|
||||
Console.WriteLine("Hello World");
|
||||
@ -46,7 +52,6 @@ namespace Learning
|
||||
Console.Write("Hello ");
|
||||
Console.Write("World");
|
||||
|
||||
|
||||
///////////////////////////////////////////////////
|
||||
// Types & Variables
|
||||
//
|
||||
@ -61,140 +66,83 @@ namespace Learning
|
||||
// (0 <= byte <= 255)
|
||||
byte fooByte = 100;
|
||||
|
||||
// Short - Signed 16-bit integer
|
||||
// (-32,768 <= short <= 32,767)
|
||||
// Short - 16-bit integer
|
||||
// Signed - (-32,768 <= short <= 32,767)
|
||||
// Unsigned - (0 <= ushort <= 65,535)
|
||||
short fooShort = 10000;
|
||||
|
||||
// Ushort - Unsigned 16-bit integer
|
||||
// (0 <= ushort <= 65,535)
|
||||
ushort fooUshort = 10000;
|
||||
|
||||
// Integer - Signed 32-bit integer
|
||||
// (-2,147,483,648 <= int <= 2,147,483,647)
|
||||
int fooInt = 1;
|
||||
// Integer - 32-bit integer
|
||||
int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
|
||||
uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
|
||||
|
||||
// Uinteger - Unsigned 32-bit integer
|
||||
// (0 <= uint <= 4,294,967,295)
|
||||
uint fooUint = 1;
|
||||
|
||||
// Long - Signed 64-bit integer
|
||||
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
|
||||
long fooLong = 100000L;
|
||||
// Long - 64-bit integer
|
||||
long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
|
||||
ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
|
||||
// Numbers default to being int or uint depending on size.
|
||||
// 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
|
||||
// Precision: 15-16 digits
|
||||
double fooDouble = 123.4;
|
||||
|
||||
// Decimal - a 128-bits data type, with more precision than other floating-point types,
|
||||
// suited for financial and monetary calculations
|
||||
decimal fooDecimal = 150.3m;
|
||||
double fooDouble = 123.4; // Precision: 15-16 digits
|
||||
|
||||
// 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,
|
||||
// suited for financial and monetary calculations
|
||||
decimal fooDecimal = 150.3m;
|
||||
|
||||
// Boolean - true & false
|
||||
bool fooBoolean = true;
|
||||
bool barBoolean = false;
|
||||
bool fooBoolean = true; // or false
|
||||
|
||||
// Char - A single 16-bit Unicode character
|
||||
char fooChar = 'A';
|
||||
|
||||
// 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
|
||||
string fooString = "My string is here!";
|
||||
// a string is a reference type. That is, you can set it to null
|
||||
string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
|
||||
Console.WriteLine(fooString);
|
||||
// You can access each character of the string with an indexer:
|
||||
char charFromString = fooString[1]; // 'y'
|
||||
// Strings are immutable: you can't do fooString[1] = 'X';
|
||||
|
||||
// formatting
|
||||
// You can access each character of the string with an indexer:
|
||||
char charFromString = fooString[1]; // 'y'
|
||||
// Strings are immutable: you can't do fooString[1] = 'X';
|
||||
|
||||
// Compare strings with current culture, ignoring case
|
||||
string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
|
||||
|
||||
// Formatting, based on sprintf
|
||||
string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
|
||||
Console.WriteLine(fooFormattedString);
|
||||
|
||||
// formatting dates
|
||||
// Dates & Formatting
|
||||
DateTime fooDate = DateTime.Now;
|
||||
Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
|
||||
|
||||
// \n is an escaped character that starts a new line
|
||||
string barString = "Printing on a new line?\nNo Problem!";
|
||||
Console.WriteLine(barString);
|
||||
|
||||
// it can be written prettier by using the @ symbol
|
||||
// You can split a string over two lines with the @ symbol. To escape " use ""
|
||||
string bazString = @"Here's some stuff
|
||||
on a new line!";
|
||||
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);
|
||||
on a new line! ""Wow!"", the masses cried";
|
||||
|
||||
// Use const or read-only to make a variable immutable
|
||||
// const values are calculated at compile time
|
||||
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
|
||||
///////////////////////////////////////////////////
|
||||
Console.WriteLine("\n->Data Structures");
|
||||
|
||||
// Arrays
|
||||
// Arrays - zero indexed
|
||||
// The array size must be decided upon declaration
|
||||
// The format for declaring an array is follows:
|
||||
// <datatype>[] <var name> = new <datatype>[<array size>];
|
||||
int[] intArray = new int[10];
|
||||
string[] stringArray = new string[1];
|
||||
bool[] boolArray = new bool[100];
|
||||
|
||||
// Another way to declare & initialize an array
|
||||
int[] y = { 9000, 1000, 1337 };
|
||||
|
||||
// Indexing an array - Accessing an element
|
||||
Console.WriteLine("intArray @ 0: " + intArray[0]);
|
||||
|
||||
// Arrays are zero-indexed and mutable.
|
||||
// Arrays are mutable.
|
||||
intArray[1] = 1;
|
||||
Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
|
||||
|
||||
// Lists
|
||||
// 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<int> intList = new List<int>();
|
||||
List<string> stringList = new List<string>();
|
||||
|
||||
// Another way to declare & initialize a list
|
||||
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]);
|
||||
List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
|
||||
// The <> are for generics - Check out the cool stuff section
|
||||
|
||||
// Lists don't default to a value;
|
||||
// A value must be added before accessing the index
|
||||
intList.Add(1);
|
||||
Console.WriteLine("intList @ 0: " + intList[0]);
|
||||
|
||||
|
||||
// Others data structures to check out:
|
||||
//
|
||||
// Stack/Queue
|
||||
// Dictionary (an implementation of a hash map)
|
||||
// HashSet
|
||||
// Read-only Collections
|
||||
// Tuple (.Net 4+)
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Operators
|
||||
///////////////////////////////////////
|
||||
@ -232,10 +173,7 @@ namespace Learning
|
||||
int i1 = 1, i2 = 2; // Shorthand for multiple declarations
|
||||
|
||||
// Arithmetic is straightforward
|
||||
Console.WriteLine("1+2 = " + (i1 + i2)); // => 3
|
||||
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)
|
||||
Console.WriteLine(i1 + i2 - i1 * 3 / 7); //
|
||||
|
||||
// Modulo
|
||||
Console.WriteLine("11%3 = " + (11 % 3)); // => 2
|
||||
@ -266,7 +204,6 @@ namespace Learning
|
||||
Console.WriteLine(i--); //i = 1. Post-Decrementation
|
||||
Console.WriteLine(--i); //i = 0. Pre-Decrementation
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Control Structures
|
||||
///////////////////////////////////////
|
||||
@ -291,50 +228,37 @@ namespace Learning
|
||||
// A simple if/else can be written as follows
|
||||
// <condition> ? <true> : <false>
|
||||
string isTrue = (true) ? "True" : "False";
|
||||
Console.WriteLine("Ternary demo: " + isTrue);
|
||||
|
||||
|
||||
// While loop
|
||||
int fooWhile = 0;
|
||||
while (fooWhile < 100)
|
||||
{
|
||||
//Console.WriteLine(fooWhile);
|
||||
//Increment the counter
|
||||
//Iterated 99 times, fooWhile 0->99
|
||||
fooWhile++;
|
||||
}
|
||||
Console.WriteLine("fooWhile Value: " + fooWhile);
|
||||
|
||||
// Do While Loop
|
||||
int fooDoWhile = 0;
|
||||
do
|
||||
{
|
||||
//Console.WriteLine(fooDoWhile);
|
||||
//Increment the counter
|
||||
//Iterated 99 times, fooDoWhile 0->99
|
||||
fooDoWhile++;
|
||||
} while (fooDoWhile < 100);
|
||||
Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
|
||||
|
||||
// For Loop
|
||||
int fooFor;
|
||||
//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
|
||||
}
|
||||
Console.WriteLine("fooFor Value: " + fooFor);
|
||||
|
||||
// For Each Loop
|
||||
|
||||
// For Each Loop
|
||||
// foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
|
||||
// The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
|
||||
// All the collection types (Array, List, Dictionary...) in the .Net framework
|
||||
// implement one or both of these interfaces.
|
||||
// (The ToCharArray() could be removed, because a string also implements IEnumerable)
|
||||
// The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
|
||||
// All the collection types (Array, List, Dictionary...) in the .Net framework
|
||||
// implement one or both of these interfaces.
|
||||
// (The ToCharArray() could be removed, because a string also implements IEnumerable)
|
||||
foreach (char character in "Hello World".ToCharArray())
|
||||
{
|
||||
//Console.WriteLine(character);
|
||||
//Iterated over all the characters in the string
|
||||
}
|
||||
|
||||
@ -356,20 +280,18 @@ namespace Learning
|
||||
case 3:
|
||||
monthString = "March";
|
||||
break;
|
||||
// You can assign more than one case to an action
|
||||
// But you can't add an action without a break before another case
|
||||
// (if you want to do this, you would have to explicitly add a goto case x
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
monthString = "Summer time!!";
|
||||
break;
|
||||
// You can assign more than one case to an action
|
||||
// But you can't add an action without a break before another case
|
||||
// (if you want to do this, you would have to explicitly add a goto case x
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
monthString = "Summer time!!";
|
||||
break;
|
||||
default:
|
||||
monthString = "Some other month";
|
||||
break;
|
||||
}
|
||||
Console.WriteLine("Switch Case Result: " + monthString);
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Converting Data Types And Typecasting
|
||||
@ -384,46 +306,228 @@ namespace Learning
|
||||
// try parse will default to type default on failure
|
||||
// in this case: 0
|
||||
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 class has a number of methods to facilitate conversions
|
||||
Convert.ToString(123);
|
||||
// or
|
||||
tryInt.ToString();
|
||||
}
|
||||
|
||||
///////////////////////////////////////
|
||||
// Classes And Functions
|
||||
///////////////////////////////////////
|
||||
|
||||
Console.WriteLine("\n->Classes & Functions");
|
||||
|
||||
// (definition of the Bicycle class follows)
|
||||
///////////////////////////////////////
|
||||
// CLASSES - see definitions at end of file
|
||||
///////////////////////////////////////
|
||||
public static void Classes()
|
||||
{
|
||||
// See Declaration of objects at end of file
|
||||
|
||||
// Use new to instantiate a class
|
||||
Bicycle trek = new Bicycle();
|
||||
|
||||
// Call object methods
|
||||
trek.speedUp(3); // You should always use setter and getter methods
|
||||
trek.setCadence(100);
|
||||
trek.SpeedUp(3); // You should always use setter and getter methods
|
||||
trek.Cadence = 100;
|
||||
|
||||
// ToString is a convention to display the value of this Object.
|
||||
Console.WriteLine("trek info: " + trek.ToString());
|
||||
|
||||
// Instantiate another new Bicycle
|
||||
Bicycle octo = new Bicycle(5, 10);
|
||||
Console.WriteLine("octo info: " + octo.ToString());
|
||||
Console.WriteLine("trek info: " + trek.Info());
|
||||
|
||||
// Instantiate a new Penny Farthing
|
||||
PennyFarthing funbike = new PennyFarthing(1, 10);
|
||||
Console.WriteLine("funbike info: " + funbike.ToString());
|
||||
Console.WriteLine("funbike info: " + funbike.Info());
|
||||
|
||||
Console.Read();
|
||||
} // 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
|
||||
|
||||
// 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:
|
||||
// <public/private/protected/internal> class <class name>{
|
||||
@ -434,64 +538,88 @@ namespace Learning
|
||||
public class Bicycle
|
||||
{
|
||||
// Bicycle's Fields/Variables
|
||||
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
|
||||
internal int wheels; // Internal: Accessible from within the assembly
|
||||
string name; // Everything is private by default: Only accessible from within this class
|
||||
public int Cadence // Public: Can be accessed from anywhere
|
||||
{
|
||||
get // get - define a method to retrieve the property
|
||||
{
|
||||
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
|
||||
// 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.
|
||||
// An enum can't contain the same value twice.
|
||||
public enum Brand
|
||||
// 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.
|
||||
// An enum can't contain the same value twice.
|
||||
public enum BikeBrand
|
||||
{
|
||||
AIST,
|
||||
BMC,
|
||||
Electra=42, //you can explicitly set a value to a name
|
||||
Electra = 42, //you can explicitly set a value to a name
|
||||
Gitane
|
||||
}
|
||||
// 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
|
||||
|
||||
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 public int bicyclesCreated = 0;
|
||||
// You can access them without a reference to any object:
|
||||
// Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
|
||||
static public int BicyclesCreated = 0;
|
||||
|
||||
// readonly values are set at run time
|
||||
// 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
|
||||
// This is a default constructor
|
||||
private Bicycle()
|
||||
public Bicycle()
|
||||
{
|
||||
gear = 1;
|
||||
cadence = 50;
|
||||
this.Gear = 1; // you can access mmebers of the object with the keyword this
|
||||
Cadence = 50; // but you don't always need it
|
||||
_speed = 5;
|
||||
name = "Bontrager";
|
||||
brand = Brand.AIST;
|
||||
bicyclesCreated++;
|
||||
Name = "Bontrager";
|
||||
Brand = BikeBrand.AIST;
|
||||
BicyclesCreated++;
|
||||
}
|
||||
|
||||
// This is a specified constructor (it contains arguments)
|
||||
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
|
||||
this.cadence = startCadence;
|
||||
this._speed = startSpeed;
|
||||
this.name = name; // it can be useful when there's a name conflict
|
||||
this.hasCardsInSpokes = hasCardsInSpokes;
|
||||
this.brand = brand;
|
||||
Gear = startGear;
|
||||
Cadence = startCadence;
|
||||
_speed = startSpeed;
|
||||
Name = name;
|
||||
_hasCardsInSpokes = hasCardsInSpokes;
|
||||
Brand = brand;
|
||||
}
|
||||
|
||||
// Constructors can be chained
|
||||
public Bicycle(int startCadence, int startSpeed, Brand brand) :
|
||||
this(startCadence, startSpeed, 0, "big wheels", true)
|
||||
public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
|
||||
this(startCadence, startSpeed, 0, "big wheels", true, brand)
|
||||
{
|
||||
}
|
||||
|
||||
@ -501,27 +629,8 @@ namespace Learning
|
||||
// classes can implement getters and setters for their fields
|
||||
// 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.
|
||||
// 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)
|
||||
{
|
||||
_speed += increment;
|
||||
@ -541,12 +650,12 @@ namespace Learning
|
||||
get { return _hasTassles; }
|
||||
set { _hasTassles = value; }
|
||||
}
|
||||
|
||||
// You can also define an automatic property in one line
|
||||
// this syntax will create a backing field automatically.
|
||||
// You can set an access modifier on either the getter or the setter (or both)
|
||||
// to restrict its access:
|
||||
public bool IsBroken { get; private set; }
|
||||
|
||||
// You can also define an automatic property in one line
|
||||
// this syntax will create a backing field automatically.
|
||||
// You can set an access modifier on either the getter or the setter (or both)
|
||||
// to restrict its access:
|
||||
public bool IsBroken { get; private set; }
|
||||
|
||||
// Properties can be auto-implemented
|
||||
public int FrameSize
|
||||
@ -558,13 +667,13 @@ namespace Learning
|
||||
}
|
||||
|
||||
//Method to display the attribute values of this Object.
|
||||
public override string ToString()
|
||||
public virtual string Info()
|
||||
{
|
||||
return "gear: " + gear +
|
||||
" cadence: " + cadence +
|
||||
" speed: " + _speed +
|
||||
" name: " + name +
|
||||
" cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") +
|
||||
return "Gear: " + Gear +
|
||||
" Cadence: " + Cadence +
|
||||
" Speed: " + _speed +
|
||||
" Name: " + Name +
|
||||
" Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
|
||||
"\n------------------------------\n"
|
||||
;
|
||||
}
|
||||
@ -573,9 +682,10 @@ namespace Learning
|
||||
public static bool DidWeCreateEnoughBycles()
|
||||
{
|
||||
// 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.
|
||||
|
||||
|
||||
} // end class Bicycle
|
||||
|
||||
// PennyFarthing is a subclass of Bicycle
|
||||
@ -586,20 +696,27 @@ namespace Learning
|
||||
|
||||
// calling parent constructor
|
||||
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 ";
|
||||
result += base.ToString(); // Calling the base version of the method
|
||||
return reuslt;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
@ -624,7 +741,7 @@ namespace Learning
|
||||
damage += meters;
|
||||
}
|
||||
|
||||
public void Broken
|
||||
public bool Broken
|
||||
{
|
||||
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
|
||||
|
||||
* Flags
|
||||
* Attributes
|
||||
* Generics (T), Delegates, Func, Actions, lambda expressions
|
||||
* Static properties
|
||||
* Exceptions, Abstraction
|
||||
* LINQ
|
||||
* ASP.NET (Web Forms/MVC/WebMatrix)
|
||||
* Winforms
|
||||
* Windows Presentation Foundation (WPF)
|
||||
|
||||
|
||||
|
||||
## Further Reading
|
||||
|
||||
* [DotNetPerls](http://www.dotnetperls.com)
|
||||
|
||||
@ -44,7 +44,7 @@ math =
|
||||
# "cube": function(x) { return x * square(x); }
|
||||
#}
|
||||
|
||||
# Símbolos:
|
||||
# Número de argumentos variable:
|
||||
race = (winner, runners...) ->
|
||||
print winner, runners
|
||||
|
||||
@ -52,6 +52,6 @@ race = (winner, runners...) ->
|
||||
alert "I knew it!" if elvis?
|
||||
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
|
||||
|
||||
# Colecciones por comprensión:
|
||||
# Listas:
|
||||
cubes = (math.cube num for num in list) #=> ...
|
||||
```
|
||||
|
||||
@ -156,9 +156,9 @@ li[4] # Lève un 'IndexError'
|
||||
# On peut accèder à des rangs de valeurs avec la syntaxe "slice"
|
||||
# (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
|
||||
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]
|
||||
# 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]
|
||||
|
||||
# Retirer un élément spécifique dee la liste avec "del"
|
||||
|
||||
@ -11,7 +11,7 @@ makes coding a real joy for me.
|
||||
```haskell
|
||||
-- Single line comments start with two dashes.
|
||||
{- Multiline comments can be enclosed
|
||||
en a block like this.
|
||||
in a block like this.
|
||||
-}
|
||||
|
||||
----------------------------------------------------
|
||||
|
||||
@ -8,7 +8,7 @@ filename: learnjulia.jl
|
||||
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.
|
||||
|
||||
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
|
||||
|
||||
@ -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.
|
||||
|
||||
# You have numbers
|
||||
# There are several basic types of numbers.
|
||||
3 #=> 3 (Int64)
|
||||
3.2 #=> 3.2 (Float64)
|
||||
2 + 1im #=> 2 + 1im (Complex{Int64})
|
||||
2//3 #=> 2//3 (Rational{Int64})
|
||||
|
||||
# Math is what you would expect
|
||||
# All of the normal infix operators are available.
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
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 / 2 #=> 2.5
|
||||
div(5, 2) #=> 2
|
||||
2 ^ 2 #=> 4 # power, not bitwise xor
|
||||
12 % 10 #=> 2
|
||||
|
||||
@ -77,11 +77,13 @@ false
|
||||
# Strings are created with "
|
||||
"This is a string."
|
||||
|
||||
# Character literals written with '
|
||||
# Character literals are written with '
|
||||
'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
|
||||
# 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:
|
||||
"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4"
|
||||
@ -94,10 +96,10 @@ false
|
||||
## 2. Variables and Collections
|
||||
####################################################
|
||||
|
||||
# Printing is pretty easy
|
||||
# Printing is easy
|
||||
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
|
||||
|
||||
@ -108,12 +110,14 @@ catch e
|
||||
println(e)
|
||||
end
|
||||
|
||||
# Variable name start with a letter. You can use uppercase letters, digits,
|
||||
# and exclamation points as well after the initial alphabetic character.
|
||||
# Variable names start with a letter.
|
||||
# After that, you can use letters, digits, underscores, and exclamation points.
|
||||
SomeOtherVar123! = 6 #=> 6
|
||||
|
||||
# You can also use unicode characters
|
||||
☃ = 8 #=> 8
|
||||
# These are especially handy for mathematical notation
|
||||
2 * π #=> 6.283185307179586
|
||||
|
||||
# A note on naming conventions in Julia:
|
||||
#
|
||||
@ -158,6 +162,10 @@ a[1] #=> 1 # remember that Julia indexes from 1, not 0!
|
||||
# indexing expression
|
||||
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
|
||||
# their argument.
|
||||
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.
|
||||
a[1:3] #=> [1, 2, 3]
|
||||
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]
|
||||
splice!(arr,2) #=> 4 ; arr is now [3,5]
|
||||
|
||||
# Concatenate lists with append!
|
||||
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
|
||||
contains(a,1) #=> true
|
||||
# Check for existence in a list with in
|
||||
in(a,1) #=> true
|
||||
|
||||
# Examine the length with length
|
||||
length(a) #=> 7
|
||||
length(a) #=> 8
|
||||
|
||||
# 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
|
||||
try:
|
||||
tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
|
||||
@ -209,22 +218,26 @@ end
|
||||
# Many list functions also work on tuples
|
||||
length(tup) #=> 3
|
||||
tup[1:2] #=> (1,2)
|
||||
contains(tup,2) #=> true
|
||||
in(tup,2) #=> true
|
||||
|
||||
# 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
|
||||
|
||||
# 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)
|
||||
|
||||
# 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
|
||||
|
||||
|
||||
# Dictionaries store mappings
|
||||
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]
|
||||
# => Dict{ASCIIString,Int64}
|
||||
|
||||
@ -241,31 +254,35 @@ values(filled_dict)
|
||||
#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
|
||||
# Note - Same as above regarding key ordering.
|
||||
|
||||
# Check for existence of keys in a dictionary with contains, haskey
|
||||
contains(filled_dict, ("one", 1)) #=> true
|
||||
contains(filled_dict, ("two", 3)) #=> false
|
||||
# Check for existence of keys in a dictionary with in, haskey
|
||||
in(filled_dict, ("one", 1)) #=> true
|
||||
in(filled_dict, ("two", 3)) #=> false
|
||||
haskey(filled_dict, "one") #=> true
|
||||
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
|
||||
filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489
|
||||
catch e
|
||||
println(e)
|
||||
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(filled_dict,"one",4) #=> 1
|
||||
get(filled_dict,"four",4) #=> 4
|
||||
|
||||
# Sets store sets
|
||||
# Use Sets to represent collections of unordered, unique values
|
||||
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)
|
||||
|
||||
# Add more items to a set
|
||||
add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1)
|
||||
# Add more values to a set
|
||||
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.
|
||||
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)
|
||||
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
|
||||
@ -285,8 +298,7 @@ contains(filled_set,10) #=> false
|
||||
# Let's make a variable
|
||||
some_var = 5
|
||||
|
||||
# Here is an if statement. Indentation is NOT meaningful in Julia.
|
||||
# prints "some var is smaller than 10"
|
||||
# Here is an if statement. Indentation is not meaningful in Julia.
|
||||
if some_var > 10
|
||||
println("some_var is totally bigger than 10.")
|
||||
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.
|
||||
println("some_var is indeed 10.")
|
||||
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"]
|
||||
# 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")
|
||||
end
|
||||
# prints:
|
||||
@ -307,31 +329,33 @@ end
|
||||
# cat 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"]
|
||||
println("$(a[1]) is $(a[2])")
|
||||
println("$(a[1]) is a $(a[2])")
|
||||
end
|
||||
# prints:
|
||||
# dog is a mammal
|
||||
# cat is a mammal
|
||||
# mouse is a mammal
|
||||
|
||||
for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
|
||||
println("$k is $v")
|
||||
println("$k is a $v")
|
||||
end
|
||||
|
||||
|
||||
# While loops go until a condition is no longer met.
|
||||
# prints:
|
||||
# 0
|
||||
# 1
|
||||
# 2
|
||||
# 3
|
||||
# dog is a mammal
|
||||
# cat is a mammal
|
||||
# mouse is a mammal
|
||||
|
||||
# While loops loop while a condition is true
|
||||
x = 0
|
||||
while x < 4
|
||||
println(x)
|
||||
x += 1 # Shorthand for x = x + 1
|
||||
end
|
||||
# prints:
|
||||
# 0
|
||||
# 1
|
||||
# 2
|
||||
# 3
|
||||
|
||||
# Handle exceptions with a try/except block
|
||||
try
|
||||
@ -346,11 +370,14 @@ end
|
||||
## 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)
|
||||
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
|
||||
end
|
||||
|
||||
@ -360,13 +387,16 @@ add(5, 6) #=> 11 after printing out "x is 5 and y is 6"
|
||||
# positional arguments
|
||||
function varargs(args...)
|
||||
return args
|
||||
# use the keyword return to return anywhere in the function
|
||||
end
|
||||
#=> varargs (generic function with 1 method)
|
||||
|
||||
varargs(1,2,3) #=> (1,2,3)
|
||||
|
||||
# The ... is called a splat.
|
||||
# It can also be used in a fuction call
|
||||
# to splat a list or tuple out to be the arguments
|
||||
# We just used it in a function definition.
|
||||
# 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{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() #=> ["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")
|
||||
println("normal arg: $normal_arg")
|
||||
println("optional arg: $optional_positional_arg")
|
||||
@ -420,12 +450,15 @@ function create_adder(x)
|
||||
return adder
|
||||
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)
|
||||
y -> x + y
|
||||
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 adder(y)
|
||||
x + y
|
||||
@ -436,61 +469,114 @@ end
|
||||
add_10 = create_adder(10)
|
||||
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
|
||||
map(add_10, [1,2,3]) #=> [11, 12, 13]
|
||||
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 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
|
||||
taillength::Float64
|
||||
coatcolor # no type annotation is implicitly Any
|
||||
coatcolor # not including a type annotation is the same as `::Any`
|
||||
end
|
||||
# default constructor is the properties in order
|
||||
# so, Tiger(taillength,coatcolor)
|
||||
|
||||
# Type instantiation
|
||||
tigger = Tiger(3.5,"orange") # the type doubles as the constructor function
|
||||
# The default constructor's arguments are the properties
|
||||
# of the tyep, in order the order they are listed in the definition
|
||||
tigger = Tiger(3.5,"orange") #=> Tiger(3.5,"orange")
|
||||
|
||||
# The type doubles as the constructor function for values of that type
|
||||
sherekhan = typeof(tigger)(5.6,"fire") #=> Tiger(5.6,"fire")
|
||||
|
||||
# Abtract Types
|
||||
# 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
|
||||
|
||||
# * types defined with the type keyword are concrete types; they can be
|
||||
# instantiated
|
||||
#
|
||||
# * types defined with the abstract keyword are abstract types; they can
|
||||
# have subtypes.
|
||||
#
|
||||
# * each type has one supertype; a supertype can have zero or more subtypes.
|
||||
# Abstract types cannot be instantiated, but can have subtypes.
|
||||
# For example, Number is an abstract type
|
||||
subtypes(Number) #=> 6-element Array{Any,1}:
|
||||
# Complex{Float16}
|
||||
# Complex{Float32}
|
||||
# Complex{Float64}
|
||||
# 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
|
||||
mane_color
|
||||
roar::String
|
||||
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
|
||||
eye_color
|
||||
Panther() = new("green")
|
||||
# Panthers will only have this constructor, and no default constructor.
|
||||
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
|
||||
# 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)
|
||||
cat.roar # access properties using dot notation
|
||||
cat.roar # access type properties using dot notation
|
||||
end
|
||||
|
||||
function meow(cat::Panther)
|
||||
@ -501,21 +587,75 @@ function meow(cat::Tiger)
|
||||
"rawwwr"
|
||||
end
|
||||
|
||||
# Testing the meow function
|
||||
meow(tigger) #=> "rawwr"
|
||||
meow(Lion("brown","ROAAR")) #=> "ROAAR"
|
||||
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)
|
||||
println("The cat says $(meow(cat))")
|
||||
end
|
||||
|
||||
pet_cat(Lion("42")) #=> prints "The cat says 42"
|
||||
try
|
||||
pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,)
|
||||
catch e
|
||||
println(e)
|
||||
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/)
|
||||
|
||||
The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
|
||||
|
||||
Loading…
Reference in New Issue
Block a user