1, 'Two' => 2, 'Three' => 3);
+
+// PHP 5.4 a introduit une nouvelle syntaxe
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // affiche 1
+
+// Dans une liste simple, l'index est automatiquement attribué en tant que clé
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+// Ajoute un élément à la fin du tableau
+$array[] = 'Four';
+
+// Retrait d'un élément du tableau
+unset($array[3]);
+
+/********************************
+ * Affichage
+ */
+
+echo('Hello World!');
+// Affiche Hello World! dans stdout.
+// Stdout est la page web si on exécute depuis un navigateur.
+
+print('Hello World!'); // Pareil à "écho"
+
+// Pour écho, vous n'avez pas besoin des parenthèses
+echo 'Hello World!';
+print 'Hello World!'; // Pour print non plus
+
+$paragraph = 'paragraph';
+
+echo 100; // Affichez un scalaire directement
+echo $paragraph; // ou des variables
+
+// Si le raccourci de sortie est configuré, ou si votre version de PHP est
+// 5.4.0+, vous pouvez utiliser ceci:
+?>
+
+ 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Affiche le type et la valeur de la variable dans stdout
+var_dump($z); // prints int(0)
+
+// Affiche la variable dans stdout dans un format plus convivial
+print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
+
+/********************************
+ * Logique
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert affiche un avertissement dans son argument n'est pas vrai
+
+// Ces comparaisons vont toujours être vraies, même si leurs
+// types ne sont pas les mêmes.
+assert($a == $b); // égalité
+assert($c != $a); // inégalité
+assert($c <> $a); // inégalité (moins courant)
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Ces comparaisons vont seulement être vraies si les types concordent.
+assert($c === $d);
+assert($a !== $d);
+assert(1 === '1');
+assert(1 !== '1');
+
+// Opérateur 'spaceship' depuis PHP 7
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 car ils sont égaux
+echo $a <=> $b; // -1 car $a < $b
+echo $b <=> $a; // 1 car $b > $a
+
+// Les variables peuvent être transtypées dépendamment de leur usage.
+
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2
+
+$string = 'one';
+echo $string + $string; // => 0
+// Donne 0 car l'opérateur + ne peut pas transtyper la chaîne 'one' en un nombre
+
+// On peut également transtyper manuellement pour utiliser
+// une variable dans un autre type
+
+$boolean = (boolean) 1; // => true
+
+$zero = 0;
+$boolean = (boolean) $zero; // => false
+
+// Il y a également des fonctions dédiées pour transtyper
+$integer = 5;
+$string = strval($integer);
+
+$var = null; // Valeur nulle
+
+
+/********************************
+ * Structures de contrôle
+ */
+
+if (true) {
+ print 'Je suis affiché';
+}
+
+if (false) {
+ print 'Je ne le suis pas';
+} else {
+ print 'Je suis affiché';
+}
+
+if (false) {
+ print 'Je ne suis pas affiché';
+} elseif (true) {
+ print 'Je le suis';
+}
+
+// Opérateur ternaire
+print (false ? 'N\'est pas affiché' : 'L\'est');
+
+// Opérateur ternaire depuis PHP 5.3
+// équivalent de $x ? $x : 'Does'
+$x = false;
+print($x ?: 'Does');
+
+// depuis PHP 7, on peut facilement vérifier si une valeur est nulle
+$a = null;
+$b = 'Hello World';
+echo $a ?? 'a is not set'; // Affiche 'a is not set'
+echo $b ?? 'b is not set'; // Affiche 'Hello World'
+
+
+$x = 0;
+if ($x === '0') {
+ print 'Pas affiché';
+} elseif($x == '1') {
+ print 'Pas affiché';
+} else {
+ print 'Affiché';
+}
+
+
+// Cette syntaxe alternative est particulièrement utile avec du HTML:
+?>
+
+
+Ceci est affiché si $x est vrai
+
+Ceci est affiché si $x est faux
+
+
+ 2, 'car' => 4];
+
+// Les boucles 'foreach' sont utiles pour parcourir les tableaux
+foreach ($wheels as $wheel_count) {
+ echo $wheel_count;
+} // Affiche "24"
+
+echo "\n";
+
+// Il est également possible d'accéder aux clés du tableau
+foreach ($wheels as $vehicle => $wheel_count) {
+ echo "The $vehicle have $wheel_count wheels";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+ if ($i === 3) {
+ break; // Permet d'arrêter la boucle
+ }
+ echo $i++;
+} // Affiche "012"
+
+for ($i = 0; $i < 5; $i++) {
+ if ($i === 3) {
+ continue; // Permet de passer immédiatement à l'itération suivante
+ }
+ echo $i;
+} // Affiche "0124"
+
+
+/********************************
+ * Fonctions
+ */
+
+// On peut déclarer une fonction avec le mot clé 'function'
+function my_function () {
+ return 'Hello';
+}
+
+echo my_function(); // => "Hello"
+
+
+// Les noms de fonction débutent par le symbole $
+// Un nom de variable valide commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
+
+function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
+ $result = $x + $y;
+ return $result;
+}
+
+echo add(4); // => 5
+echo add(4, 2); // => 6
+
+// $result n'est pas accessible en dehors de la fonction
+// print $result; // Retourne un avertissement
+
+// Depuis PHP 5.3 on peut déclarer des fonctions anonymes
+$inc = function ($x) {
+ return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+ echo "$x - $y - $z";
+}
+
+// Une fonction peut retourner une fonction
+function bar ($x, $y) {
+ // On peut utiliser 'use' pour passer des variables externes
+ return function ($z) use ($x, $y) {
+ foo($x, $y, $z);
+ };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Affiche "A - B - C"
+
+// On peut exécuter une fonction par son nom en chaîne de caractères
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Utile pour déterminer par programmation quelle fonction exécuter.
+
+// On peut également utiliser
+call_user_func(callable $callback [, $parameter [, ... ]]);
+
+/********************************
+ * Insertions
+ */
+
+instanceProp = $instanceProp;
+ }
+
+ // Les méthodes sont déclarés par des fonctions au sein de la classe
+ public function myMethod()
+ {
+ print 'MyClass';
+ }
+
+ // le mot clé 'final' rend la function impossible à surcharger
+ final function youCannotOverrideMe()
+ {
+ }
+
+/*
+ * Les attributs et méthodes statiques peuvent être accédés sans devoir
+ * instancier la classe. Les attributs statiques ne sont pas accessibles depuis
+ * une instance, même si les méthodes statiques le sont.
+ */
+
+ public static function myStaticMethod()
+ {
+ print 'I am static';
+ }
+}
+
+// Les constantes d'une classe peuvent toujours être utilisé de façon statique
+echo MyClass::MY_CONST; // Outputs 'value';
+
+echo MyClass::$staticVar; // Retourne 'static';
+MyClass::myStaticMethod(); // Retourne 'I am static';
+
+// On peut instancier une classe en utilisant le mot clé 'new'
+$my_class = new MyClass('An instance property');
+
+// On peut accéder aux attributs/méthodes d'une instance avec ->
+echo $my_class->property; // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod(); // => "MyClass"
+
+
+// On peut hériter d'une classe en utilisant 'extends'
+class MyOtherClass extends MyClass
+{
+ function printProtectedProperty()
+ {
+ echo $this->prot;
+ }
+
+ // Surcharge d'une méthode
+ function myMethod()
+ {
+ parent::myMethod();
+ print ' > MyOtherClass';
+ }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // => Retourne "protected"
+$my_other_class->myMethod(); // Retourne "MyClass > MyOtherClass"
+
+// On peut empêcher qu'une classe soit héritée
+final class YouCannotExtendMe
+{
+}
+
+// On peut utiliser des "méthodes magiques" pour se faire des accesseurs
+class MyMapClass
+{
+ private $property;
+
+ public function __get($key)
+ {
+ return $this->$key;
+ }
+
+ public function __set($key, $value)
+ {
+ $this->$key = $value;
+ }
+}
+
+$x = new MyMapClass();
+echo $x->property; // Va utiliser la méthode __get()
+$x->property = 'Something'; // Va utiliser la méthode __set()
+
+// Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou
+// elle peuvent implémenter une interface (en utilisant le mot clé 'implement').
+
+// Une interface peut être déclarée avec le mot clé 'interface'
+
+interface InterfaceOne
+{
+ public function doSomething();
+}
+
+interface InterfaceTwo
+{
+ public function doSomethingElse();
+}
+
+// Les interfaces peuvent hériter d'autres interfaces
+interface InterfaceThree extends InterfaceTwo
+{
+ public function doAnotherContract();
+}
+
+abstract class MyAbstractClass implements InterfaceOne
+{
+ public $x = 'doSomething';
+}
+
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
+{
+ public function doSomething()
+ {
+ echo $x;
+ }
+
+ public function doSomethingElse()
+ {
+ echo 'doSomethingElse';
+ }
+}
+
+
+// Les classes peuvent implémenter plusieurs interfaces à la fois
+class SomeOtherClass implements InterfaceOne, InterfaceTwo
+{
+ public function doSomething()
+ {
+ echo 'doSomething';
+ }
+
+ public function doSomethingElse()
+ {
+ echo 'doSomethingElse';
+ }
+}
+
+/********************************
+ * Espaces de noms (namespaces)
+ */
+
+// Cette section est séparée, car une déclaration d'espace de nom doit être
+// la première chose que l'on retrouve dans un fichier PHP,
+// imaginons que c'est le cas
+
+> .gitignore
+$ echo "private_key" >> .gitignore
+```
+
+
### status
-To show differences between the index file (basically your working copy/repo) and the current
-HEAD commit.
+To show differences between the index file (basically your working copy/repo)
+and the current HEAD commit.
```bash
@@ -172,7 +181,8 @@ $ git add /path/to/file/HelloWorld.c
$ git add ./*.java
```
-This only adds a file to the staging area/index, it doesn't commit it to the working directory/repo.
+This only adds a file to the staging area/index, it doesn't commit it to the
+working directory/repo.
### branch
@@ -205,7 +215,8 @@ Updates all files in the working tree to match the version in the index, or spec
$ git checkout
# Checkout a specified branch
$ git checkout branchName
-# Create a new branch & switch to it, like: "git branch ; git checkout "
+# Create a new branch & switch to it
+# equivalent to "git branch ; git checkout "
$ git checkout -b newBranch
```
@@ -218,6 +229,10 @@ to a remote branch.
```bash
# Clone learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+# shallow clone - faster cloning that pulls only latest snapshot
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+# clone only a specific branch
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
```
### commit
@@ -231,6 +246,9 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
# automatically stage modified or deleted files, except new files, and then commit
$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# change last commit (this deletes previous commit with a fresh commit)
+$ git commit --amend -m "Correct message"
```
### diff
@@ -268,7 +286,7 @@ $ git config --global alias.g "grep --break --heading --line-number"
$ git grep 'variableName' -- '*.java'
# Search for a line that contains "arrayListName" and, "add" or "remove"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
Google is your friend; for more examples
@@ -282,8 +300,8 @@ Display commits to the repository.
# Show all commits
$ git log
-# Show X number of commits
-$ git log -n 10
+# Show only commit message & ref
+$ git log --oneline
# Show merge commits only
$ git log --merges
@@ -303,7 +321,7 @@ $ git merge --no-ff branchName
### mv
-Rename or move a file
+Rename or move a file
```bash
# Renaming a file
@@ -338,7 +356,7 @@ $ git pull origin master --rebase
Push and merge changes from a branch to a remote & branch.
```bash
-# Push and merge changes from a local repo to a
+# Push and merge changes from a local repo to a
# remote named "origin" and "master" branch.
# git push
# git push => implicitly defaults to => git push origin master
@@ -347,23 +365,25 @@ $ git push origin master
# To link up current local branch with a remote branch, add -u flag:
$ git push -u origin master
# Now, anytime you want to push from that same local branch, use shortcut:
-$ git push
+$ git push
```
### stash
-Stashing takes the dirty state of your working directory and saves it on a stack of unfinished changes that you can reapply at any time.
+Stashing takes the dirty state of your working directory and saves it on a stack
+of unfinished changes that you can reapply at any time.
-Let's say you've been doing some work in your git repo, but you want to pull from the remote.
-Since you have dirty (uncommited) changes to some files, you are not able to run `git pull`.
-Instead, you can run `git stash` to save your changes onto a stack!
+Let's say you've been doing some work in your git repo, but you want to pull
+from the remote. Since you have dirty (uncommited) changes to some files, you
+are not able to run `git pull`. Instead, you can run `git stash` to save your
+changes onto a stack!
```bash
$ git stash
Saved working directory and index state \
"WIP on master: 049d078 added the index file"
HEAD is now at 049d078 added the index file
- (To restore them type "git stash apply")
+ (To restore them type "git stash apply")
```
Now you can pull!
@@ -410,7 +430,7 @@ Now you're ready to get back to work on your stuff!
[Additional Reading.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
-### rebase (caution)
+### rebase (caution)
Take all changes that were committed on one branch, and replay them onto another branch.
*Do not rebase commits that you have pushed to a public repo*.
diff --git a/groovy.html.markdown b/groovy.html.markdown
index 519f36ce..492c1ba2 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -99,7 +99,7 @@ technologies.sort()
// To sort without mutating original, you can do:
sortedTechnologies = technologies.sort( false )
-/*** Manipulating Lists ***/
+/*** Manipulating Lists ***/e
//Replace all elements in the list
Collections.replaceAll(technologies, 'Gradle', 'gradle')
@@ -200,6 +200,14 @@ def y = 10
def x = (y > 1) ? "worked" : "failed"
assert x == "worked"
+//Groovy supports 'The Elvis Operator' too!
+//Instead of using the ternary operator:
+
+displayName = user.name ? user.name : 'Anonymous'
+
+//We can write it:
+displayName = user.name ?: 'Anonymous'
+
//For loop
//Iterate over a range
def x = 0
@@ -422,6 +430,3 @@ Join a [Groovy user group](http://www.groovy-lang.org/usergroups.html)
[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
-
-
-
diff --git a/hack.html.markdown b/hack.html.markdown
index 632fc705..b9730dc0 100644
--- a/hack.html.markdown
+++ b/hack.html.markdown
@@ -2,6 +2,7 @@
language: Hack
contributors:
- ["Stephen Holdaway", "https://github.com/stecman"]
+ - ["David Lima", "https://github.com/davelima"]
filename: learnhack.hh
---
@@ -152,7 +153,7 @@ class ArgumentPromotion
private bool $isAwesome) {}
}
-class WithoutArugmentPromotion
+class WithoutArgumentPromotion
{
public string $name;
@@ -169,9 +170,9 @@ class WithoutArugmentPromotion
}
-// Co-oprerative multi-tasking
+// Co-operative multi-tasking
//
-// Two new keywords "async" and "await" can be used to perform mutli-tasking
+// Two new keywords "async" and "await" can be used to perform multi-tasking
// Note that this does not involve threads - it just allows transfer of control
async function cooperativePrint(int $start, int $end) : Awaitable
{
diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown
index 8e8cdf4e..c1e985aa 100644
--- a/id-id/xml-id.html.markdown
+++ b/id-id/xml-id.html.markdown
@@ -5,6 +5,7 @@ contributors:
- ["João Farias", "https://github.com/JoaoGFarias"]
translators:
- ["Rizky Luthfianto", "https://github.com/rilut"]
+lang: id-id
---
XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data.
diff --git a/java.html.markdown b/java.html.markdown
index 928eb39f..478ec683 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -47,10 +47,30 @@ public class LearnJava {
///////////////////////////////////////
- // Types & Variables
+ // Variables
///////////////////////////////////////
-
+
+ /*
+ * Variable Declaration
+ */
// Declare a variable using
+ int fooInt;
+ // Declare multiple variables of the same type , ,
+ int fooInt1, fooInt2, fooInt3;
+
+ /*
+ * Variable Initialization
+ */
+
+ // Initialize a variable using =
+ int fooInt = 1;
+ // Initialize multiple variables of same type with same value , , =
+ int fooInt1, fooInt2, fooInt3;
+ fooInt1 = fooInt2 = fooInt3 = 1;
+
+ /*
+ * Variable types
+ */
// Byte - 8-bit signed two's complement integer
// (-128 <= byte <= 127)
byte fooByte = 100;
@@ -305,6 +325,33 @@ public class LearnJava {
// toString returns this Object's string representation.
System.out.println("trek info: " + trek.toString());
+
+ // Double Brace Initialization
+ // The Java Language has no syntax for how to create static Collections
+ // in an easy way. Usually you end up in the following way:
+
+ private static final Set COUNTRIES = new HashSet();
+ static {
+ validCodes.add("DENMARK");
+ validCodes.add("SWEDEN");
+ validCodes.add("FINLAND");
+ }
+
+ // But there's a nifty way to achive the same thing in an
+ // easier way, by using something that is called Double Brace
+ // Initialization.
+
+ private static final Set COUNTRIES = HashSet() {{
+ add("DENMARK");
+ add("SWEDEN");
+ add("FINLAND");
+ }}
+
+ // The first brace is creating an new AnonymousInnerClass and the
+ // second one declares and instance initializer block. This block
+ // is called with the anonymous inner class is created.
+ // This does not only work for Collections, it works for all
+ // non-final classes.
} // End main method
} // End LearnJava class
@@ -451,6 +498,74 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
public void InterfaceTwoMethod() {
}
}
+
+
+// Abstract Classes
+// Abstract Class declaration syntax
+// abstract extends {
+// // Constants and variables
+// // Method declarations
+// }
+
+// Methods can't have bodies in an interface, unless the method is
+// static. Also variables are NOT final by default, unlike an interface.
+// Also abstract classes CAN have the "main" method.
+// Abstract classes solve these problems.
+
+public abstract class Animal
+{
+ public abstract void makeSound();
+
+ // Method can have a body
+ public void eat()
+ {
+ System.out.println("I am an animal and I am Eating.");
+ // Note: We can access private variable here.
+ age = 30;
+ }
+
+ // No need to initialize, however in an interface
+ // a variable is implicitly final and hence has
+ // to be initialized.
+ private int age;
+
+ public void printAge()
+ {
+ System.out.println(age);
+ }
+
+ // Abstract classes can have main function.
+ public static void main(String[] args)
+ {
+ System.out.println("I am abstract");
+ }
+}
+
+class Dog extends Animal
+{
+ // Note still have to override the abstract methods in the
+ // abstract class.
+ @Override
+ public void makeSound()
+ {
+ System.out.println("Bark");
+ // age = 30; ==> ERROR! age is private to Animal
+ }
+
+ // NOTE: You will get an error if you used the
+ // @Override annotation here, since java doesn't allow
+ // overriding of static methods.
+ // What is happening here is called METHOD HIDING.
+ // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+ public static void main(String[] args)
+ {
+ Dog pluto = new Dog();
+ pluto.makeSound();
+ pluto.eat();
+ pluto.printAge();
+ }
+}
+
```
## Further Reading
diff --git a/json.html.markdown b/json.html.markdown
index f57b82b8..47a8cb21 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -49,7 +49,7 @@ going to be 100% valid JSON. Luckily, it kind of speaks for itself.
"alternative style": {
"comment": "check this out!"
- , "comma position": "doesn't matter - as long as its before the value, then its valid"
+ , "comma position": "doesn't matter - as long as it's before the value, then it's valid"
, "another comment": "how nice"
},
diff --git a/ko-kr/javascript-kr.html.markdown b/ko-kr/javascript-kr.html.markdown
index 4ca3bb5c..9561e80c 100644
--- a/ko-kr/javascript-kr.html.markdown
+++ b/ko-kr/javascript-kr.html.markdown
@@ -387,9 +387,6 @@ myNumber === myNumberObj // = false
if (0){
// 0은 거짓이라서 이 코드는 실행되지 않습니다.
}
-if (Number(0)){
- // Number(0)은 참이라서 이 코드는 *실행됩니다*.
-}
// 하지만 래퍼 객체와 일반 내장 함수는 프로토타입을 공유하기 때문에
// 가령 문자열에 실제로 기능을 추가할 수 있습니다.
diff --git a/markdown.html.markdown b/markdown.html.markdown
index 6d19710f..acb808ea 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -160,7 +160,7 @@ def foobar
end
\`\`\`
-<-- The above text doesn't require indenting, plus Github will use syntax
+
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 91b84b47..407ba3c8 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -5,6 +5,7 @@ contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"]
- ["Levi Bostian", "https://github.com/levibostian"]
+ - ["Clayton Walker", "https://github.com/cwalk"]
filename: LearnObjectiveC.m
---
@@ -747,4 +748,8 @@ __unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not se
[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
+[Programming with Objective-C for iOS](https://developer.apple.com/library/ios/documentation/General/Conceptual/DevPedia-CocoaCore/ObjectiveC.html)
+
+[Programming with Objective-C for Mac OSX](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html)
+
[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
diff --git a/php.html.markdown b/php.html.markdown
index 3fcce264..93066284 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -215,6 +215,14 @@ assert($a !== $d);
assert(1 === '1');
assert(1 !== '1');
+// spaceship operator since PHP 7
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 since they are equal
+echo $a <=> $b; // -1 since $a < $b
+echo $b <=> $a; // 1 since $b > $a
+
// Variables can be converted between types, depending on their usage.
$integer = 1;
@@ -264,6 +272,18 @@ if (false) {
// ternary operator
print (false ? 'Does not get printed' : 'Does');
+// ternary shortcut operator since PHP 5.3
+// equivalent of "$x ? $x : 'Does'""
+$x = false;
+print($x ?: 'Does');
+
+// null coalesce operator since php 7
+$a = null;
+$b = 'Does print';
+echo $a ?? 'a is not set'; // prints 'a is not set'
+echo $b ?? 'b is not set'; // prints 'Does print'
+
+
$x = 0;
if ($x === '0') {
print 'Does not print';
@@ -689,4 +709,4 @@ If you're coming from a language with good package management, check out
[Composer](http://getcomposer.org/).
For common standards, visit the PHP Framework Interoperability Group's
-[PSR standards](https://github.com/php-fig/fig-standards).
+[PSR standards](https://github.com/php-fig/fig-standards).
\ No newline at end of file
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
index c7ce55ee..9e4b458d 100644
--- a/pt-br/brainfuck-pt.html.markdown
+++ b/pt-br/brainfuck-pt.html.markdown
@@ -5,10 +5,11 @@ contributors:
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["Suzane Sant Ana", "http://github.com/suuuzi"]
+ - ["Rodrigo Muniz", "http://github.com/muniz95"]
lang: pt-br
---
-Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de
+Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
programação Turing-completa extremamente simples com apenas 8 comandos.
```
@@ -18,7 +19,7 @@ Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
e um ponteiro de dados que aponta para a célula atual.
Existem 8 comandos:
-+ : Incrementa o vaor da célula atual em 1.
++ : Incrementa o valor da célula atual em 1.
- : Decrementa o valor da célula atual em 1.
> : Move o ponteiro de dados para a célula seguinte (célula à direita).
< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
diff --git a/pt-br/hack-pt.html.markdown b/pt-br/hack-pt.html.markdown
new file mode 100644
index 00000000..7c938149
--- /dev/null
+++ b/pt-br/hack-pt.html.markdown
@@ -0,0 +1,316 @@
+---
+language: Hack
+contributors:
+ - ["Stephen Holdaway", "https://github.com/stecman"]
+ - ["David Lima", "https://github.com/davelima"]
+translators:
+ - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnhack-pt.hh
+---
+
+Hack é uma linguagem baseada no PHP e roda numa máquina virtual chamada HHVM.
+Hack é quase completamente interoperável com códigos PHP existentes e adiciona
+alguns recursos úteis de linguagens estaticamente tipadas.
+
+Somente recursos específicos da linguagem Hack serão abordados aqui. Detalhes
+sobre a sintaxe do PHP estão disponíveis no
+[artigo PHP](http://learnxinyminutes.com/docs/php/) neste site.
+
+```php
+id = $id;
+ }
+}
+
+
+// Funções anônimas (lambdas)
+$multiplicador = 5;
+array_map($y ==> $y * $multiplicador, [1, 2, 3]);
+
+
+// Genéricos
+class Caixa
+{
+ protected T $dados;
+
+ public function __construct(T $dados) {
+ $this->dados = $dados;
+ }
+
+ public function pegaDados(): T {
+ return $this->dados;
+ }
+}
+
+function abreCaixa(Caixa $caixa) : int
+{
+ return $caixa->pegaDados();
+}
+
+
+// Formas
+//
+// Hack adiciona o conceito de formas para definir arrays com uma estrutura
+// e tipos de dados garantidos
+type Point2D = shape('x' => int, 'y' => int);
+
+function distancia(Point2D $a, Point2D $b) : float
+{
+ return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distancia(
+ shape('x' => -1, 'y' => 5),
+ shape('x' => 2, 'y' => 50)
+);
+
+
+// Pseudônimos de tipos
+//
+// Hack adiciona vários recursos para criação de pseudônimos, tornando tipos complexos
+// mais fáceis de entender
+newtype VectorArray = array>;
+
+// Um tuple contendo dois inteiros
+newtype Point = (int, int);
+
+function adicionaPontos(Point $p1, Point $p2) : Point
+{
+ return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+adicionaPontos(
+ tuple(1, 2),
+ tuple(5, 6)
+);
+
+
+// enums em classes
+enum TipoDePista : int
+{
+ Estrada = 0;
+ Rua = 1;
+ Alameda = 2;
+ Avenida = 3;
+}
+
+function getTipoDePista() : TipoDePista
+{
+ return TipoDePista::Alameda;
+}
+
+
+// Especificação de argumentos no construtor (Argument Promotion)
+//
+// Para evitar que propriedades sejam definidas em mais de um lugar, e
+// construtores que só definem propriedades, o Hack adiciona uma sintaxe para
+// definir as propriedades e o construtor ao mesmo tempo.
+class ArgumentPromotion
+{
+ public function __construct(public string $nome,
+ protected int $idade,
+ private bool $legal) {}
+}
+
+class SemArgumentPromotion
+{
+ public string $nome;
+
+ protected int $idade;
+
+ private bool $legal;
+
+ public function __construct(string $nome, int $idade, bool $legal)
+ {
+ $this->nome = $nome;
+ $this->idade = $idade;
+ $this->legal = $legal;
+ }
+}
+
+
+// Multi-tarefas cooperativo
+//
+// Duas novas palavras-chave ("async" e "await") podem ser usadas para
+// trabalhar com multi-tarefas.
+// Obs. Isto não envolve threads - apenas permite a transferência de controle
+async function printCooperativo(int $inicio, int $fim) : Awaitable
+{
+ for ($i = $inicio; $i <= $fim; $i++) {
+ echo "$i ";
+
+ // Permite que outras tarefas façam algo
+ await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+ }
+}
+
+// Imprime "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+ printCooperativo(1, 3),
+ printCooperativo(4, 6),
+ printCooperativo(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributos
+//
+// Atributos são uma forma de definir metadados para funções.
+// Hack tem alguns atributos especiais que possuem comportamentos úteis.
+
+// O atributo especial __Memoize faz com que o resultado da função fique em cache
+<<__Memoize>>
+function tarefaDemorada() : ?string
+{
+ return file_get_contents('http://exemplo.com');
+}
+
+// O corpo da função só é executado uma vez aqui:
+tarefaDemorada();
+tarefaDemorada();
+
+
+// O atributo especial __ConsistentConstruct faz com que o Hack certifique-se
+// de que a assinatura do construtor seja a mesma em todas as subclasses
+<<__ConsistentConstruct>>
+class FooConsistente
+{
+ public function __construct(int $x, float $y)
+ {
+ // ...
+ }
+
+ public function algumMetodo()
+ {
+ // ...
+ }
+}
+
+class BarConsistente extends FooConsistente
+{
+ public function __construct(int $x, float $y)
+ {
+ // O verificador de tipos do Hack exige que os construtores pai
+ // sejam chamados
+ parent::__construct($x, $y);
+
+ // ...
+ }
+
+ // A anotação __Override é uma anotação opcional que faz com que o
+ // verificador de tipos do Hack sobrescreva um método em uma classe pai
+ // ou um trait. Sem __Override, definir este método causará um erro,
+ // pois ele já foi definido na classe pai (FooConsistente):
+ <<__Override>>
+ public function algumMetodo()
+ {
+ // ...
+ }
+}
+
+class SubclasseFooInvalida extends FooConsistente
+{
+ // Caso o construtor não combine com o construtor da classe pai, o
+ // verificador de tipos acusará um erro:
+ //
+ // "Este objeto é incompatível com o objeto FooConsistente porque algum(ns)
+ // dos seus métodos são incompatíveis"
+ //
+ public function __construct(float $x)
+ {
+ // ...
+ }
+
+ // Usar a anotação __Override em um método que não existe na classe pai
+ // causará um erro do verificador de tipos:
+ // "SubclasseFooInvalida::outroMetodo() está marcada para sobrescrever;
+ // nenhuma definição não-privada foi encontrada ou a classe pai foi
+ // definida em código não->
+ public function outroMetodo()
+ {
+ // ...
+ }
+}
+
+
+// Traits podem implementar interfaces (não suportado pelo PHP)
+interface InterfaceGatinho
+{
+ public function brinca() : void;
+}
+
+trait TraitGato implements InterfaceGatinho
+{
+ public function brinca() : void
+ {
+ // ...
+ }
+}
+
+class Samuel
+{
+ use TraitGato;
+}
+
+
+$gato = new Samuel();
+$gato instanceof InterfaceGatinho === true; // True
+
+```
+
+## Mais informações
+
+Visite a [documentação do Hack](http://docs.hhvm.com/manual/en/hacklangref.php)
+para ver explicações detalhadas dos recursos que Hack adiciona ao PHP, ou o [site oficial do Hack](http://hanlang.org/)
+para outras informações.
+
+Visite o [site oficial do HHVM](http://hhvm.com/) para aprender a instalar o HHVM.
+
+Visite [este artigo](http://docs.hhvm.com/manual/en/hack.unsupported.php) para ver
+os recursos do PHP que o Hack não suporta e ver incompatibilidades entre Hack e PHP.
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
new file mode 100644
index 00000000..406042fa
--- /dev/null
+++ b/pt-br/javascript-pt.html.markdown
@@ -0,0 +1,547 @@
+---
+language: javascript
+contributors:
+ - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+ - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+ - ["Willian Justen", "http://willianjusten.com.br"]
+lang: pt-br
+---
+
+JavaScript foi criada por Brendan Eich, funcionário da Netscape na época, em 1995. Ela
+foi originalmente criada para ser uma linguagem de script para websites,
+complementando o uso de Java para aplicações web mais complexas, mas a sua
+integração com páginas web e seu suporte nativo nos browsers fez com que
+ela se tornasse mais comum que Java no frontend web.
+
+Javascript não é somente limitada a browsers web, existindo o Node.js,
+que é um projeto que fornece um interpretador baseado no motor V8 do Google
+Chrome e está se tornando cada vez mais famoso.
+
+Feedback são muito apreciados! Você me encontrar em
+[@adambrenecki](https://twitter.com/adambrenecki), ou
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Comentários são como em C. Comentários de uma linha começam com duas barras,
+/* e comentários de múltplas linhas começam com barra-asterisco
+ e fecham com asterisco-barra */
+
+// comandos podem ser terminados com ;
+facaAlgo();
+
+// ... mas eles não precisam ser, o ponto-e-vírgula é automaticamente
+// inserido quando há uma nova linha, exceto alguns casos.
+facaAlgo()
+
+// Como esses casos podem causar resultados inesperados, vamos continuar
+// a usar ponto-e-vírgula neste guia.
+
+///////////////////////////////////
+// 1. Números, Strings e Operadores
+
+// Javascript tem um tipo de número (que é o 64-bit IEEE 754 double).
+// Doubles tem uma mantissa 52-bit, que é suficiente para guardar inteiros
+// acima de 9✕10¹⁵ precisamente.
+3; // = 3
+1.5; // = 1.5
+
+// A aritmética básica funciona como seria de se esperar.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Inclusive divisão desigual.
+5 / 2; // = 2.5
+
+// Operadores Bitwise também funcionam; quando você faz uma operação bitwise
+// seu float é convertido para um int de até 32 bits.
+1 << 2; // = 4
+
+// A precedência é aplicada com parênteses.
+(1 + 3) * 2; // = 8
+
+// Existem três especiais valores não-é-número-real:
+Infinity; // resultado de 1/0
+-Infinity; // resultado de -1/0
+NaN; // resultado de 0/0
+
+// Existe também o tipo booleano.
+true;
+false;
+
+// Strings são criados com ' ou ".
+'abc';
+"Olá, mundo";
+
+// Negação usa o símbolo !
+!true; // = false
+!false; // = true
+
+// Igualdade é o sinal de ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Desigualdade é o sinal de !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Mais comparações
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings são concatenadas com +
+"Olá " + "mundo!"; // = "Olá mundo!"
+
+// e comparadas com < e >
+"a" < "b"; // = true
+
+// A comparação de tipos não é feita com o uso de ==...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...a menos que use ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...isso pode resultar em comportamentos estranhos...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Você pode acessar caracteres de uma String usando o `charAt`
+"Isto é uma String".charAt(0); // = 'I'
+
+// ...ou usar `substring` para pegar pedaços maiores.
+"Olá mundo".substring(0, 3); // = "Olá"
+
+// `length` é uma propriedade, portanto não use ().
+"Olá".length; // = 3
+
+// Existe também o `null` e o `undefined`.
+null; // usado para indicar um valor não considerado
+undefined; // usado para indicar um valor que não é a atualmente definido
+ // (entretando `undefined` é considerado de fato um valor
+
+// false, null, undefined, NaN, 0 and "" são valores falsos;
+// qualquer outro valor é verdadeiro
+// Note que 0 é falso e "0" é verdadeiro, até mesmo 0 == "0".
+
+///////////////////////////////////
+// 2. Variáveis, Arrays e Objetos
+
+// Variáveis são declaradas com a palavra-chave `var`. O Javascript é
+// dinâmicamente tipado, portanto você não precisa especificar o tipo.
+// Atribuições usam um simples caracter de `=`.
+var someVar = 5;
+
+// se você deixar de colocar a palavra-chave var, você não irá receber um erro...
+someOtherVar = 10;
+
+// ...mas sua variável será criada no escopo global, não no escopo em que você
+// definiu ela.
+
+// Variáveis declaradas sem receberem um valor são definidas como `undefined`.
+var someThirdVar; // = undefined
+
+// Existe um shorthand para operações matemáticas em variáveis:
+someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora
+someVar *= 10; // agora someVar é 100
+
+// e um para adição e subtração de 1
+someVar++; // agora someVar é 101
+someVar--; // volta para 100
+
+// Arrays são listas ordenadas de valores, de qualquer tipo.
+var myArray = ["Olá", 45, true];
+
+// Seus membros podem ser acessados usando a sintaxe de colchetes.
+// O indíce de um Array começa pelo 0.
+myArray[1]; // = 45
+
+// Arrays são mutáveis e de tamanho variável.
+myArray.push("World");
+myArray.length; // = 4
+
+// Adicionar/modificar em um índice específico
+myArray[3] = "Hello";
+
+// Objetos de Javascript são equivalentes aos dicionários ou maps de outras
+// linguagens: uma coleção não ordenada de pares chave-valor.
+var myObj = {chave1: "Olá", chave2: "Mundo"};
+
+// Chaves são strings, mas as aspas não são necessárias se elas são
+// identificadores válidos no Javascript. Valores podem ser de qualquer tipo.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Atributos de objetos também podem ser acessados com a sintaxe de colchetes.
+myObj["my other key"]; // = 4
+
+// ... ou usando a sintaxe de ponto, passando a chave que é um identificador
+// válido.
+myObj.myKey; // = "myValue"
+
+// Objetos são mutáveis, valores podem ser modificados e novas chaves
+// adicionadas.
+myObj.myThirdKey = true;
+
+// Se você tentar acessar um valor que não foi determinado ainda, você irá
+// receber `undefined`.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Lógica e Estruturas de Controle
+
+// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
+
+// The `if` structure works as you'd expect.
+// A estrutura `if` funciona como deveria ser.
+var count = 1
+if (count == 3){
+ // executa se count é 3
+} else if (count == 4){
+ // executa se count é 4
+} else {
+ // executa se count não é 3 nem 4
+}
+
+// Como se faz um `while`.
+while (true){
+ // Um loop infinito!
+}
+
+// Os loops do-while são como os loops de while, exceto quando eles sempre
+// executam pelo menos uma vez.
+do {
+ input = getInput();
+} while (!isValid(input))
+
+// The `for` loop is the same as C and Java:
+// initialisation; continue condition; iteration.
+
+// O loop `for` é o mesmo de C e Java:
+// inicialização, condição para continuar; iteração
+for (var i = 0; i < 5; i++){
+ // vai rodar cinco vezes
+}
+
+// && é o `e` lógico , || é o `ou` lógico
+if (house.size == "big" && house.colour == "blue"){
+ house.contains = "bear";
+}
+if (cor == "red" || cor == "blue"){
+ // cor é vermelha OU azul
+}
+
+// && e || "pequeno circuito", é útil para determinar valores padrões.
+var name = otherName || "padrão";
+
+// O `switch` checa pela igualdade com `===`.
+// Use `break` após cada `case`
+grade = 'B';
+switch (grade) {
+ case 'A':
+ console.log("Great job");
+ break;
+ case 'B':
+ console.log("OK job");
+ break;
+ case 'C':
+ console.log("You can do better");
+ break;
+ default:
+ console.log("Oy vey");
+ break;
+}
+
+
+///////////////////////////////////
+// 4. Funções, Escopos e Closures
+
+// Funções Javascript são declaradas com a palavra-chave `function`.
+function myFunction(thing){
+ return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Repare que o valor a ser retornado deve começar na mesma linha que
+// a palavra-chave `return`, senão você sempre irá retornar `undefined`
+// visto que o ponto-e-vírgula é inserido automáticamente nas quebras de
+// linha. Preste atenção quando usar o estilo Allman.
+function myFunction()
+{
+ return // <- ponto-e-vírgula adicionado automaticamente aqui
+ {
+ thisIsAn: 'object literal'
+ }
+}
+myFunction(); // = undefined
+
+// Funções Javascript são objetos de primeira classe, portanto elas podem
+// ser atribuídas a nomes de variáveis e serem passadas para outras funções
+// como argumentos - por exemplo, quando criamos um manipulador de eventos:
+function myFunction(){
+ // este código será chamado em 5 segundos
+}
+setTimeout(myFunction, 5000);
+// Nota: `setTimeout` não é parte da linguagem Javascript, mas é provido pelos
+// browsers e o Node.js.
+
+// Objetos de funções não precisam nem serem declarados com nome - você pode
+// escrever a definição de uma função anônima diretamente nos argumentos de
+// outra função.
+setTimeout(function(){
+ // este código será chamado em 5 segundos
+}, 5000);
+
+// O Javascript tem escopo de função; as funções tem seu próprio escopo,
+// mas outros blocos não.
+if (true){
+ var i = 5;
+}
+i; // = 5 - não `undefined` como você esperaria numa linguagem de blogo-escopo
+
+// Isso levou a padrão comum chamado de IIFE (Imediately Invoked Function
+// Expression) ou (Expressão de Função Invocada Imediatamente), que previne
+// que variáveis temporárias vazem para o escopo global.
+(function(){
+ var temporary = 5;
+ // Nós podemos acessar o escopo global definindo o "objeto global", que
+ // no browser vai ser sempre `window`. O objeto global pode ter um nome
+ // diferente para ambiente não-browser como o Node.js.
+ window.permanent = 10;
+})();
+temporary; // levanta um erro de referência inexiste
+permanent; // = 10
+
+// Uma das principais características do Javascript é a closure. Que é
+// uma função definida dentro de outra função, a função interna pode acessar
+// todas as variáveis da função externa, mesmo depois da função de fora
+// finalizar sua execução.
+function sayHelloInFiveSeconds(name){
+ var prompt = "Hello, " + name + "!";
+
+ // Funções internas são colocadas no escopo local por padrão, assim como
+ // se fossem declaradas com `var`.
+ function inner(){
+ alert(prompt);
+ }
+ setTimeout(inner, 5000);
+ // `setTimeout` é assíncrono, portanto a função `sayHelloInFiveSeconds`
+ // vai sair imediatamente, e o `setTimeout` irá chamar a interna depois.
+ // Entretanto. como a interna é fechada dentro de "sayHelloInFiveSeconds",
+ // a interna permanece podendo acessar a variável `prompt` quando depois
+ // de chamada.
+}
+sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s
+
+///////////////////////////////////
+// 5. Mais sobre Objetos; Construtores e Prototypes
+
+// Objetos podem conter funções.
+var myObj = {
+ myFunc: function(){
+ return "Olá mundo!";
+ }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// Quando uma função ligada a um objeto é chamada, ela pode acessar o objeto
+// da qual foi ligada usando a palavra-chave `this`.
+myObj = {
+ myString: "Olá mundo!",
+ myFunc: function(){
+ return this.myString;
+ }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// O `this` só funciona para dentro do escopo do objeto, portanto, se chamarmos
+// um método do objeto fora de seu escopo, este não irá funcionar.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// através do `this`, até mesmo se ela não for chamada quando foi definida.
+var myOtherFunc = function(){
+ return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "OLÁ MUNDO!"
+
+// Nós podemos também especificar um contexto onde a função irá executar,
+// usando o `call` ou `apply`.
+
+var anotherFunc = function(s){
+ return this.myString + s;
+}
+anotherFunc.call(myObj, " E Olá Lua!"); // = "Olá mundo! E Olá Lua!"
+
+// A função `apply` é praticamente a mesma coisa, mas ela pega um array
+// como lista de argumentos.
+
+anotherFunc.apply(myObj, [" E Olá Sol!"]); // = "Olá mundo! E Olá Sol!"
+
+// Isto é util quando trabalhamos com uma função que aceita uma sequência de
+// argumentos e você quer passar um array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Mas, o `call` e `apply` são somente temporários. Quando você quiser que
+// permaneça sempre no escopo, use `bind`.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" E Olá Saturno!"); // = "Olá mundo! E Olá Saturno!"
+
+// `bind` também pode ser usado para parcialmente aplicar (curry) uma função.
+
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Quando você invoca uma função com a palavra-chave `new`, um novo objeto
+// é criado, e fica disponível para a função pela palavra-chave `this`.
+// Funções são desenhadas para serem invocadas como se invocam os construtores.
+
+var MyConstructor = function(){
+ this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Todo objeto JavaScript possui um `prototype`. Quando você tenta acessar
+// uma propriedade de um objeto que não existe no objeto atual, o interpretador
+// vai olhar imediatamente para o seu prototype.
+
+// Algumas implementações em JS deixam você acessar o objeto prototype com a
+// propriedade mágica `__proto__`. Enquanto isso é util para explicar
+// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de
+// usar prototypes depois.
+
+var myObj = {
+ myString: "Olá Mundo!"
+};
+var myPrototype = {
+ meaningOfLife: 42,
+ myFunc: function(){
+ return this.myString.toLowerCase()
+ }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+// Isto funciona para funções, também.
+myObj.myFunc(); // = "olá mundo!"
+
+// É claro, se sua propriedade não está em seu prototype,
+// o prototype do prototype será procurado e por aí vai.
+myPrototype.__proto__ = {
+ myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Não há cópia envolvida aqui; cada objeto guarda uma referência do
+// prototype. Isso significa que podemos alterar o prototype e nossas mudanças
+// serão refletidas em qualquer lugar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+
+// Nós mencionamos que o `__proto__` não é uma forma padrão, e não há uma
+// forma padrão de mudar o prototype de um objeto já existente. Entretanto,
+// existem duas formas de se criar um objeto com um dado prototype.
+
+// A primeira forma é `Object.create`, que é uma adição recente do JS,
+// e ainda não está disponível em todas as implementações.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// A segunda forma, que funciona em qualquer lugar, é feita com construtores.
+// Construtores tem uma propriedade chamada prototype. Este *não* é o prototype
+// do construtor em si; ao invés disso, ele é o prototype dos novos objetos
+// criados pelo construtor.
+MyConstructor.prototype = {
+ myNumber: 5,
+ getMyNumber: function(){
+ return this.myNumber;
+ }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Tipos originais da linguagem como strings e números também possuem
+// construtores equivalentes.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Exceto, que eles não são totalmente equivalentes.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+ // O código não vai executar, porque 0 é um valor falso.
+}
+
+// Entretanto, esses objetos encapsulados e as funções originais compartilham
+// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// por exemplo.
+String.prototype.firstCharacter = function(){
+ return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Esse fato é usado para criar os chamados `polyfills`, que implementam
+// uma nova característica do Javascript em uma versão mais velha, para que
+// assim funcionem em ambientes mais velhos como browsers ultrapassados.
+
+// Havíamos mencionado que `Object.create` não estava ainda disponível em
+// todos as implementações, mas nós podemos usá-lo com esse polyfill:
+if (Object.create === undefined){ // don't overwrite it if it exists
+ Object.create = function(proto){
+ // faz um construtor temporário com o prototype certo
+ var Constructor = function(){};
+ Constructor.prototype = proto;
+ // então utiliza o new para criar um objeto prototype apropriado
+ return new Constructor();
+ }
+}
+```
+
+## Leitura Adicional
+
+O [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) dispõe de uma
+excelente documentação sobre Javascript e seu uso nos browsers. E mais,
+é uma wiki, portanto conforme você vai aprendendo, mais você pode ir ajudando
+os outros compartilhando do seu conhecimento.
+
+[Uma re-introdução do JavaScript pela MDN]
+(https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cobre muito dos conceitos abordados aqui em mais detalhes. Este guia fala
+somente sobre a linguagem JavaScript em si; se você quiser aprender mais
+sobre e como usar o JavaScript em páginas na web, comece aprendendo sobre
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Aprenda Javascript por Exemplos e com Desafios](http://www.learneroo.com/modules/64/nodes/350) é uma
+variação desse guia com desafios.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) é um guia
+profundo de todas as partes do JavaScript.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) é o guia clássico
+/ livro de referência.
+
+Parte desse artigo foi adaptado do tutorial de Python do Louie Dinh que está
+nesse site e do [Tutorial de JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+da Mozilla Developer Network.
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index 72a57e4a..e840b8cf 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -221,7 +221,7 @@ println("Gas price: \(price)")
// Número variável de argumentos
func setup(numbers: Int...) {
- // its an array
+ // é um array
let number = numbers[0]
let argCount = numbers.count
}
diff --git a/python3.html.markdown b/python3.html.markdown
index b3acb122..971ca0a4 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -4,6 +4,7 @@ contributors:
- ["Louie Dinh", "http://pythonpracticeprojects.com"]
- ["Steven Basart", "http://github.com/xksteven"]
- ["Andre Polykanine", "https://github.com/Oire"]
+ - ["Zachary Ferguson", "http://github.com/zfergus2"]
filename: learnpython3.py
---
@@ -36,7 +37,7 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
8 - 1 # => 7
10 * 2 # => 20
-# Except division which returns floats by default
+# Except division which returns floats, real numbers, by default
35 / 5 # => 7.0
# Result of integer division truncated down both for positive and negative.
@@ -51,13 +52,13 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
# Modulo operation
7 % 3 # => 1
-# Exponentiation (x to the yth power)
+# Exponentiation (x**y, x to the yth power)
2**4 # => 16
# Enforce precedence with parentheses
(1 + 3) * 2 # => 8
-# Boolean values are primitives
+# Boolean values are primitives (Note: the capitalization)
True
False
@@ -95,6 +96,16 @@ False or True #=> True
1 < 2 < 3 # => True
2 < 3 < 2 # => False
+# (is vs. ==) is checks if two variable refer to the same object, but == checks
+# if the objects pointed to have the same values.
+a = [1, 2, 3, 4] # Point a at a new list, [1, 2, 3, 4]
+b = a # Point b at what a is pointing to
+b is a # => True, a and b refer to the same object
+b == a # => True, a's and b's objects are equal
+b = [1, 2, 3, 4] # Point a at a new list, [1, 2, 3, 4]
+b is a # => False, a and b do not refer to the same object
+b == a # => True, a's and b's objects are equal
+
# Strings are created with " or '
"This is a string."
'This is also a string.'
@@ -145,6 +156,10 @@ bool({}) #=> False
# Python has a print function
print("I'm Python. Nice to meet you!")
+# By default the print function also prints out a newline at the end.
+# Use the optional argument end to change the end character.
+print("Hello, World", end="!") # => Hello, World!
+
# No need to declare variables before assigning to them.
# Convention is to use lower_case_with_underscores
some_var = 5
@@ -191,6 +206,9 @@ li[::-1] # => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# li[start:end:step]
+# Make a one layer deep copy using slices
+li2 = li[:] # => li2 = [1, 2, 4, 3] but (li2 is li) will result in false.
+
# Remove arbitrary elements from a list with "del"
del li[2] # li is now [1, 2, 3]
@@ -213,6 +231,12 @@ tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # Raises a TypeError
+# Note that a tuple of length one has to have a comma after the last element but
+# tuples of other lengths, even zero, do not.
+type((1)) # =>
+type((1,)) # =>
+type(()) # =>
+
# You can do most of the list operations on tuples too
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
@@ -232,6 +256,12 @@ empty_dict = {}
# Here is a prefilled dictionary
filled_dict = {"one": 1, "two": 2, "three": 3}
+# Note keys for dictionaries have to be immutable types. This is to ensure that
+# the key can be converted to a constant hash value for quick look-ups.
+# Immutable types include ints, floats, strings, tuples.
+invalid_dict = {[1,2,3]: "123"} # => Raises a TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]} # Values can be of any type, however.
+
# Look up values with []
filled_dict["one"] # => 1
@@ -278,6 +308,10 @@ empty_set = set()
# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
some_set = {1, 1, 2, 2, 3, 4} # some_set is now {1, 2, 3, 4}
+# Similar to keys of a dictionary, elements of a set have to be immutable.
+invalid_set = {[1], 1} # => Raises a TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
# Can set new variables to a set
filled_set = some_set
@@ -299,6 +333,7 @@ filled_set | other_set # => {1, 2, 3, 4, 5, 6}
10 in filled_set # => False
+
####################################################
## 3. Control Flow and Iterables
####################################################
@@ -352,6 +387,18 @@ for i in range(4, 8):
print(i)
"""
+"range(lower, upper, step)" returns an iterable of numbers
+from the lower number to the upper number, while incrementing
+by step. If step is not indicated, the default value is 1.
+prints:
+ 4
+ 6
+ 8
+"""
+for i in range(4, 8, 2):
+ print(i)
+"""
+
While loops go until a condition is no longer met.
prints:
0
@@ -464,6 +511,15 @@ all_the_args(*args) # equivalent to foo(1, 2, 3, 4)
all_the_args(**kwargs) # equivalent to foo(a=3, b=4)
all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+# Returning multiple values (with tuple assignments)
+def swap(x, y):
+ return y, x # Return multiple values as a tuple without the parenthesis.
+ # (Note: parenthesis have been excluded but can be included)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Again parenthesis have been excluded but can be included.
# Function Scope
x = 5
diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index 79844565..8655ae4a 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -470,9 +470,6 @@ myNumber === myNumberObj; // = false
if (0) {
// Этот код не выполнится, потому что 0 - это ложь.
}
-if (Number(0)) {
- // Этот код *выполнится*, потому что Number(0) истинно.
-}
// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
// поэтому вы можете расширить функционал строк, например:
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index 318e0e09..69b5fb46 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -158,6 +158,7 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
hash = {'color' => 'green', 'number' => 5}
hash.keys #=> ['color', 'number']
+hash.values #=> ['green', 5]
# Значение в хэше легко может быть найдено по ключу:
hash['color'] #=> 'green'
diff --git a/ruby-ecosystem.html.markdown b/ruby-ecosystem.html.markdown
index d8a02d36..1fbcc752 100644
--- a/ruby-ecosystem.html.markdown
+++ b/ruby-ecosystem.html.markdown
@@ -42,7 +42,7 @@ The three major version of Ruby in use are:
* 2.0.0 - Released in February 2013. Most major libraries and frameworks support
2.0.0.
* 1.9.3 - Released in October 2011. This is the version most rubyists use
- currently.
+ currently. Also [retired](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
* 1.8.7 - Ruby 1.8.7 has been
[retired](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
diff --git a/ruby.html.markdown b/ruby.html.markdown
index 7bd28d86..8f23b2e6 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -168,6 +168,10 @@ array[-1] #=> 5
# With a start index and length
array[2, 3] #=> [3, 4, 5]
+# Reverse an Array
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
# Or with a range
array[1..3] #=> [2, 3, 4]
diff --git a/rust.html.markdown b/rust.html.markdown
index 4fbd6144..3157fcf4 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -14,7 +14,7 @@ it possible to use Rust libraries as a "drop-in replacement" for C.
Rust’s first release, 0.1, occurred in January 2012, and for 3 years development
moved so quickly that until recently the use of stable releases was discouraged
-and instead the general advise was to use nightly builds.
+and instead the general advice was to use nightly builds.
On May 15th 2015, Rust 1.0 was released with a complete guarantee of backward
compatibility. Improvements to compile times and other aspects of the compiler are
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
new file mode 100644
index 00000000..a434a1ad
--- /dev/null
+++ b/smalltalk.html.markdown
@@ -0,0 +1,955 @@
+---
+language: smalltalk
+contributors:
+ - ["Jigyasa Grover", "https://github.com/jig08"]
+---
+
+- Smalltalk is an object-oriented, dynamically typed, reflective programming language.
+- Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human–computer symbiosis."
+- It was designed and created in part for educational use, more so for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, and others during the 1970s.
+
+Feedback highly appreciated! Reach me at [@jigyasa_grover](https://twitter.com/jigyasa_grover) or send me an e-mail at `grover.jigyasa1@gmail.com`.
+
+
+##Allowable characters:
+- a-z
+- A-Z
+- 0-9
+- .+/\*~<>@%|&?
+- blank, tab, cr, ff, lf
+
+##Variables:
+- variables must be declared before use
+- shared vars must begin with uppercase
+- local vars must begin with lowercase
+- reserved names: `nil`, `true`, `false`, `self`, `super`, and `Smalltalk`
+
+##Variable scope:
+- Global: defined in Dictionary Smalltalk and accessible by all objects in system - Special: (reserved) `Smalltalk`, `super`, `self`, `true`, `false`, & `nil`
+- Method Temporary: local to a method
+- Block Temporary: local to a block
+- Pool: variables in a Dictionary object
+- Method Parameters: automatic local vars created as a result of message call with params
+- Block Parameters: automatic local vars created as a result of value: message call
+- Class: shared with all instances of one class & its subclasses
+- Class Instance: unique to each instance of a class
+- Instance Variables: unique to each instance
+
+`"Comments are enclosed in quotes"`
+
+`"Period (.) is the statement seperator"`
+
+## Transcript:
+```
+Transcript clear. "clear to transcript window"
+Transcript show: 'Hello World'. "output string in transcript window"
+Transcript nextPutAll: 'Hello World'. "output string in transcript window"
+Transcript nextPut: $A. "output character in transcript window"
+Transcript space. "output space character in transcript window"
+Transcript tab. "output tab character in transcript window"
+Transcript cr. "carriage return / linefeed"
+'Hello' printOn: Transcript. "append print string into the window"
+'Hello' storeOn: Transcript. "append store string into the window"
+Transcript endEntry. "flush the output buffer"
+```
+
+##Assignment:
+```
+| x y |
+x _ 4. "assignment (Squeak) <-"
+x := 5. "assignment"
+x := y := z := 6. "compound assignment"
+x := (y := 6) + 1.
+x := Object new. "bind to allocated instance of a class"
+x := 123 class. "discover the object class"
+x := Integer superclass. "discover the superclass of a class"
+x := Object allInstances. "get an array of all instances of a class"
+x := Integer allSuperclasses. "get all superclasses of a class"
+x := 1.2 hash. "hash value for object"
+y := x copy. "copy object"
+y := x shallowCopy. "copy object (not overridden)"
+y := x deepCopy. "copy object and instance vars"
+y := x veryDeepCopy. "complete tree copy using a dictionary"
+```
+
+##Constants:
+```
+| b |
+b := true. "true constant"
+b := false. "false constant"
+x := nil. "nil object constant"
+x := 1. "integer constants"
+x := 3.14. "float constants"
+x := 2e-2. "fractional constants"
+x := 16r0F. "hex constant".
+x := -1. "negative constants"
+x := 'Hello'. "string constant"
+x := 'I''m here'. "single quote escape"
+x := $A. "character constant"
+x := $ . "character constant (space)"
+x := #aSymbol. "symbol constants"
+x := #(3 2 1). "array constants"
+x := #('abc' 2 $a). "mixing of types allowed"
+
+```
+
+## Booleans:
+```
+| b x y |
+x := 1. y := 2.
+b := (x = y). "equals"
+b := (x ~= y). "not equals"
+b := (x == y). "identical"
+b := (x ~~ y). "not identical"
+b := (x > y). "greater than"
+b := (x < y). "less than"
+b := (x >= y). "greater than or equal"
+b := (x <= y). "less than or equal"
+b := b not. "boolean not"
+b := (x < 5) & (y > 1). "boolean and"
+b := (x < 5) | (y > 1). "boolean or"
+b := (x < 5) and: [y > 1]. "boolean and (short-circuit)"
+b := (x < 5) or: [y > 1]. "boolean or (short-circuit)"
+b := (x < 5) eqv: (y > 1). "test if both true or both false"
+b := (x < 5) xor: (y > 1). "test if one true and other false"
+b := 5 between: 3 and: 12. "between (inclusive)"
+b := 123 isKindOf: Number. "test if object is class or subclass of"
+b := 123 isMemberOf: SmallInteger. "test if object is type of class"
+b := 123 respondsTo: sqrt. "test if object responds to message"
+b := x isNil. "test if object is nil"
+b := x isZero. "test if number is zero"
+b := x positive. "test if number is positive"
+b := x strictlyPositive. "test if number is greater than zero"
+b := x negative. "test if number is negative"
+b := x even. "test if number is even"
+b := x odd. "test if number is odd"
+b := x isLiteral. "test if literal constant"
+b := x isInteger. "test if object is integer"
+b := x isFloat. "test if object is float"
+b := x isNumber. "test if object is number"
+b := $A isUppercase. "test if upper case character"
+b := $A isLowercase. "test if lower case character"
+
+```
+
+## Arithmetic expressions:
+```
+| x |
+x := 6 + 3. "addition"
+x := 6 - 3. "subtraction"
+x := 6 * 3. "multiplication"
+x := 1 + 2 * 3. "evaluation always left to right (1 + 2) * 3"
+x := 5 / 3. "division with fractional result"
+x := 5.0 / 3.0. "division with float result"
+x := 5.0 // 3.0. "integer divide"
+x := 5.0 \\ 3.0. "integer remainder"
+x := -5. "unary minus"
+x := 5 sign. "numeric sign (1, -1 or 0)"
+x := 5 negated. "negate receiver"
+x := 1.2 integerPart. "integer part of number (1.0)"
+x := 1.2 fractionPart. "fractional part of number (0.2)"
+x := 5 reciprocal. "reciprocal function"
+x := 6 * 3.1. "auto convert to float"
+x := 5 squared. "square function"
+x := 25 sqrt. "square root"
+x := 5 raisedTo: 2. "power function"
+x := 5 raisedToInteger: 2. "power function with integer"
+x := 5 exp. "exponential"
+x := -5 abs. "absolute value"
+x := 3.99 rounded. "round"
+x := 3.99 truncated. "truncate"
+x := 3.99 roundTo: 1. "round to specified decimal places"
+x := 3.99 truncateTo: 1. "truncate to specified decimal places"
+x := 3.99 floor. "truncate"
+x := 3.99 ceiling. "round up"
+x := 5 factorial. "factorial"
+x := -5 quo: 3. "integer divide rounded toward zero"
+x := -5 rem: 3. "integer remainder rounded toward zero"
+x := 28 gcd: 12. "greatest common denominator"
+x := 28 lcm: 12. "least common multiple"
+x := 100 ln. "natural logarithm"
+x := 100 log. "base 10 logarithm"
+x := 100 log: 10. "logarithm with specified base"
+x := 100 floorLog: 10. "floor of the log"
+x := 180 degreesToRadians. "convert degrees to radians"
+x := 3.14 radiansToDegrees. "convert radians to degrees"
+x := 0.7 sin. "sine"
+x := 0.7 cos. "cosine"
+x := 0.7 tan. "tangent"
+x := 0.7 arcSin. "arcsine"
+x := 0.7 arcCos. "arccosine"
+x := 0.7 arcTan. "arctangent"
+x := 10 max: 20. "get maximum of two numbers"
+x := 10 min: 20. "get minimum of two numbers"
+x := Float pi. "pi"
+x := Float e. "exp constant"
+x := Float infinity. "infinity"
+x := Float nan. "not-a-number"
+x := Random new next; yourself. x next. "random number stream (0.0 to 1.0)
+x := 100 atRandom. "quick random number"
+
+```
+
+##Bitwise Manipulation:
+```
+| b x |
+x := 16rFF bitAnd: 16r0F. "and bits"
+x := 16rF0 bitOr: 16r0F. "or bits"
+x := 16rFF bitXor: 16r0F. "xor bits"
+x := 16rFF bitInvert. "invert bits"
+x := 16r0F bitShift: 4. "left shift"
+x := 16rF0 bitShift: -4. "right shift"
+"x := 16r80 bitAt: 7." "bit at position (0|1) [!Squeak]"
+x := 16r80 highbit. "position of highest bit set"
+b := 16rFF allMask: 16r0F. "test if all bits set in mask set in receiver"
+b := 16rFF anyMask: 16r0F. "test if any bits set in mask set in receiver"
+b := 16rFF noMask: 16r0F. "test if all bits set in mask clear in receiver"
+
+```
+
+## Conversion:
+```
+| x |
+x := 3.99 asInteger. "convert number to integer (truncates in Squeak)"
+x := 3.99 asFraction. "convert number to fraction"
+x := 3 asFloat. "convert number to float"
+x := 65 asCharacter. "convert integer to character"
+x := $A asciiValue. "convert character to integer"
+x := 3.99 printString. "convert object to string via printOn:"
+x := 3.99 storeString. "convert object to string via storeOn:"
+x := 15 radix: 16. "convert to string in given base"
+x := 15 printStringBase: 16.
+x := 15 storeStringBase: 16.
+
+```
+
+## Blocks:
+- blocks are objects and may be assigned to a variable
+- value is last expression evaluated unless explicit return
+- blocks may be nested
+- specification [ arguments | | localvars | expressions ]
+- Squeak does not currently support localvars in blocks
+- max of three arguments allowed
+- `^`expression terminates block & method (exits all nested blocks)
+- blocks intended for long term storage should not contain `^`
+
+```
+| x y z |
+x := [ y := 1. z := 2. ]. x value. "simple block usage"
+x := [ :argOne :argTwo | argOne, ' and ' , argTwo.]. "set up block with argument passing"
+Transcript show: (x value: 'First' value: 'Second'); cr. "use block with argument passing"
+"x := [ | z | z := 1.]. *** localvars not available in squeak blocks"
+```
+
+## Method calls:
+- unary methods are messages with no arguments
+- binary methods
+- keyword methods are messages with selectors including colons standard categories/protocols: - initialize-release (methods called for new instance)
+- accessing (get/set methods)
+- testing (boolean tests - is)
+- comparing (boolean tests with parameter
+- displaying (gui related methods)
+- printing (methods for printing)
+- updating (receive notification of changes)
+- private (methods private to class)
+- instance-creation (class methods for creating instance)
+```
+| x |
+x := 2 sqrt. "unary message"
+x := 2 raisedTo: 10. "keyword message"
+x := 194 * 9. "binary message"
+Transcript show: (194 * 9) printString; cr. "combination (chaining)"
+x := 2 perform: #sqrt. "indirect method invocation"
+Transcript "Cascading - send multiple messages to receiver"
+ show: 'hello ';
+ show: 'world';
+ cr.
+x := 3 + 2; * 100. "result=300. Sends message to same receiver (3)"
+```
+
+##Conditional Statements:
+```
+| x |
+x > 10 ifTrue: [Transcript show: 'ifTrue'; cr]. "if then"
+x > 10 ifFalse: [Transcript show: 'ifFalse'; cr]. "if else"
+x > 10 "if then else"
+ ifTrue: [Transcript show: 'ifTrue'; cr]
+ ifFalse: [Transcript show: 'ifFalse'; cr].
+x > 10 "if else then"
+ ifFalse: [Transcript show: 'ifFalse'; cr]
+ ifTrue: [Transcript show: 'ifTrue'; cr].
+Transcript
+ show:
+ (x > 10
+ ifTrue: ['ifTrue']
+ ifFalse: ['ifFalse']);
+ cr.
+Transcript "nested if then else"
+ show:
+ (x > 10
+ ifTrue: [x > 5
+ ifTrue: ['A']
+ ifFalse: ['B']]
+ ifFalse: ['C']);
+ cr.
+switch := Dictionary new. "switch functionality"
+switch at: $A put: [Transcript show: 'Case A'; cr].
+switch at: $B put: [Transcript show: 'Case B'; cr].
+switch at: $C put: [Transcript show: 'Case C'; cr].
+result := (switch at: $B) value.
+```
+
+## Iteration statements:
+```
+| x y |
+x := 4. y := 1.
+[x > 0] whileTrue: [x := x - 1. y := y * 2]. "while true loop"
+[x >= 4] whileFalse: [x := x + 1. y := y * 2]. "while false loop"
+x timesRepeat: [y := y * 2]. "times repear loop (i := 1 to x)"
+1 to: x do: [:a | y := y * 2]. "for loop"
+1 to: x by: 2 do: [:a | y := y / 2]. "for loop with specified increment"
+#(5 4 3) do: [:a | x := x + a]. "iterate over array elements"
+```
+
+## Character:
+```
+| x y |
+x := $A. "character assignment"
+y := x isLowercase. "test if lower case"
+y := x isUppercase. "test if upper case"
+y := x isLetter. "test if letter"
+y := x isDigit. "test if digit"
+y := x isAlphaNumeric. "test if alphanumeric"
+y := x isSeparator. "test if seperator char"
+y := x isVowel. "test if vowel"
+y := x digitValue. "convert to numeric digit value"
+y := x asLowercase. "convert to lower case"
+y := x asUppercase. "convert to upper case"
+y := x asciiValue. "convert to numeric ascii value"
+y := x asString. "convert to string"
+b := $A <= $B. "comparison"
+y := $A max: $B.
+
+```
+
+## Symbol:
+```
+| b x y |
+x := #Hello. "symbol assignment"
+y := 'String', 'Concatenation'. "symbol concatenation (result is string)"
+b := x isEmpty. "test if symbol is empty"
+y := x size. "string size"
+y := x at: 2. "char at location"
+y := x copyFrom: 2 to: 4. "substring"
+y := x indexOf: $e ifAbsent: [0]. "first position of character within string"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)]. "test if all elements meet condition"
+y := x select: [:a | a > $a]. "return all elements that meet condition"
+y := x asString. "convert symbol to string"
+y := x asText. "convert symbol to text"
+y := x asArray. "convert symbol to array"
+y := x asOrderedCollection. "convert symbol to ordered collection"
+y := x asSortedCollection. "convert symbol to sorted collection"
+y := x asBag. "convert symbol to bag collection"
+y := x asSet. "convert symbol to set collection"
+```
+
+## String:
+```
+| b x y |
+x := 'This is a string'. "string assignment"
+x := 'String', 'Concatenation'. "string concatenation"
+b := x isEmpty. "test if string is empty"
+y := x size. "string size"
+y := x at: 2. "char at location"
+y := x copyFrom: 2 to: 4. "substring"
+y := x indexOf: $a ifAbsent: [0]. "first position of character within string"
+x := String new: 4. "allocate string object"
+x "set string elements"
+ at: 1 put: $a;
+ at: 2 put: $b;
+ at: 3 put: $c;
+ at: 4 put: $e.
+x := String with: $a with: $b with: $c with: $d. "set up to 4 elements at a time"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)]. "test if all elements meet condition"
+y := x select: [:a | a > $a]. "return all elements that meet condition"
+y := x asSymbol. "convert string to symbol"
+y := x asArray. "convert string to array"
+x := 'ABCD' asByteArray. "convert string to byte array"
+y := x asOrderedCollection. "convert string to ordered collection"
+y := x asSortedCollection. "convert string to sorted collection"
+y := x asBag. "convert string to bag collection"
+y := x asSet. "convert string to set collection"
+y := x shuffled. "randomly shuffle string"
+```
+
+## Array: Fixed length collection
+- ByteArray: Array limited to byte elements (0-255)
+- WordArray: Array limited to word elements (0-2^32)
+
+```
+| b x y sum max |
+x := #(4 3 2 1). "constant array"
+x := Array with: 5 with: 4 with: 3 with: 2. "create array with up to 4 elements"
+x := Array new: 4. "allocate an array with specified size"
+x "set array elements"
+ at: 1 put: 5;
+ at: 2 put: 4;
+ at: 3 put: 3;
+ at: 4 put: 2.
+b := x isEmpty. "test if array is empty"
+y := x size. "array size"
+y := x at: 4. "get array element at index"
+b := x includes: 3. "test if element is in array"
+y := x copyFrom: 2 to: 4. "subarray"
+y := x indexOf: 3 ifAbsent: [0]. "first position of element within array"
+y := x occurrencesOf: 3. "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the array"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum array elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum array elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum array elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in array"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x shuffled. "randomly shuffle collection"
+y := x asArray. "convert to array"
+"y := x asByteArray." "note: this instruction not available on Squeak"
+y := x asWordArray. "convert to word array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+##OrderedCollection: acts like an expandable array
+```
+| b x y sum max |
+x := OrderedCollection with: 4 with: 3 with: 2 with: 1. "create collection with up to 4 elements"
+x := OrderedCollection new. "allocate collection"
+x add: 3; add: 2; add: 1; add: 4; yourself. "add element to collection"
+y := x addFirst: 5. "add element at beginning of collection"
+y := x removeFirst. "remove first element in collection"
+y := x addLast: 6. "add element at end of collection"
+y := x removeLast. "remove last element in collection"
+y := x addAll: #(7 8 9). "add multiple elements to collection"
+y := x removeAll: #(7 8 9). "remove multiple elements from collection"
+x at: 2 put: 3. "set element at index"
+y := x remove: 5 ifAbsent: []. "remove element from collection"
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+y := x at: 2. "retrieve element at index"
+y := x first. "retrieve first element in collection"
+y := x last. "retrieve last element in collection"
+b := x includes: 5. "test if element is in collection"
+y := x copyFrom: 2 to: 3. "subcollection"
+y := x indexOf: 3 ifAbsent: [0]. "first position of element within collection"
+y := x occurrencesOf: 3. "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x shuffled. "randomly shuffle collection"
+y := x asArray. "convert to array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+## SortedCollection: like OrderedCollection except order of elements determined by sorting criteria
+```
+| b x y sum max |
+x := SortedCollection with: 4 with: 3 with: 2 with: 1. "create collection with up to 4 elements"
+x := SortedCollection new. "allocate collection"
+x := SortedCollection sortBlock: [:a :c | a > c]. "set sort criteria"
+x add: 3; add: 2; add: 1; add: 4; yourself. "add element to collection"
+y := x addFirst: 5. "add element at beginning of collection"
+y := x removeFirst. "remove first element in collection"
+y := x addLast: 6. "add element at end of collection"
+y := x removeLast. "remove last element in collection"
+y := x addAll: #(7 8 9). "add multiple elements to collection"
+y := x removeAll: #(7 8 9). "remove multiple elements from collection"
+y := x remove: 5 ifAbsent: []. "remove element from collection"
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+y := x at: 2. "retrieve element at index"
+y := x first. "retrieve first element in collection"
+y := x last. "retrieve last element in collection"
+b := x includes: 4. "test if element is in collection"
+y := x copyFrom: 2 to: 3. "subcollection"
+y := x indexOf: 3 ifAbsent: [0]. "first position of element within collection"
+y := x occurrencesOf: 3. "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x asArray. "convert to array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+## Bag: like OrderedCollection except elements are in no particular order
+```
+| b x y sum max |
+x := Bag with: 4 with: 3 with: 2 with: 1. "create collection with up to 4 elements"
+x := Bag new. "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself. "add element to collection"
+x add: 3 withOccurrences: 2. "add multiple copies to collection"
+y := x addAll: #(7 8 9). "add multiple elements to collection"
+y := x removeAll: #(7 8 9). "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: []. "remove element from collection"
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+b := x includes: 3. "test if element is in collection"
+y := x occurrencesOf: 3. "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+## Set: like Bag except duplicates not allowed
+## IdentitySet: uses identity test (== rather than =)
+```
+| b x y sum max |
+x := Set with: 4 with: 3 with: 2 with: 1. "create collection with up to 4 elements"
+x := Set new. "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself. "add element to collection"
+y := x addAll: #(7 8 9). "add multiple elements to collection"
+y := x removeAll: #(7 8 9). "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: []. "remove element from collection"
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+x includes: 4. "test if element is in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x asArray. "convert to array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+## Interval:
+```
+| b x y sum max |
+x := Interval from: 5 to: 10. "create interval object"
+x := 5 to: 10.
+x := Interval from: 5 to: 10 by: 2. "create interval object with specified increment"
+x := 5 to: 10 by: 2.
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+x includes: 9. "test if element is in collection"
+x do: [:k | Transcript show: k printString; cr]. "iterate over interval"
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 7]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x asArray. "convert to array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+```
+
+##Associations:
+```
+| x y |
+x := #myVar->'hello'.
+y := x key.
+y := x value.
+```
+
+## Dictionary:
+## IdentityDictionary: uses identity test (== rather than =)
+```
+| b x y |
+x := Dictionary new. "allocate collection"
+x add: #a->4; add: #b->3; add: #c->1; add: #d->2; yourself. "add element to collection"
+x at: #e put: 3. "set element at index"
+b := x isEmpty. "test if empty"
+y := x size. "number of elements"
+y := x at: #a ifAbsent: []. "retrieve element at index"
+y := x keyAtValue: 3 ifAbsent: []. "retrieve key for given value with error block"
+y := x removeKey: #e ifAbsent: []. "remove element from collection"
+b := x includes: 3. "test if element is in values collection"
+b := x includesKey: #a. "test if element is in keys collection"
+y := x occurrencesOf: 3. "number of times object in collection"
+y := x keys. "set of keys"
+y := x values. "bag of values"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the values collection"
+x keysDo: [:a | Transcript show: a printString; cr]. "iterate over the keys collection"
+x associationsDo: [:a | Transcript show: a printString; cr]."iterate over the associations"
+x keysAndValuesDo: [:aKey :aValue | Transcript "iterate over keys and values"
+ show: aKey printString; space;
+ show: aValue printString; cr].
+b := x conform: [:a | (a >= 1) & (a <= 4)]. "test if all elements meet condition"
+y := x select: [:a | a > 2]. "return collection of elements that pass test"
+y := x reject: [:a | a < 2]. "return collection of elements that fail test"
+y := x collect: [:a | a + a]. "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: []. "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c]. "sum elements"
+max := x inject: 0 into: [:a :c | (a > c) "find max element in collection"
+ ifTrue: [a]
+ ifFalse: [c]].
+y := x asArray. "convert to array"
+y := x asOrderedCollection. "convert to ordered collection"
+y := x asSortedCollection. "convert to sorted collection"
+y := x asBag. "convert to bag collection"
+y := x asSet. "convert to set collection"
+
+Smalltalk at: #CMRGlobal put: 'CMR entry'. "put global in Smalltalk Dictionary"
+x := Smalltalk at: #CMRGlobal. "read global from Smalltalk Dictionary"
+Transcript show: (CMRGlobal printString). "entries are directly accessible by name"
+Smalltalk keys do: [ :k | "print out all classes"
+ ((Smalltalk at: k) isKindOf: Class)
+ ifFalse: [Transcript show: k printString; cr]].
+Smalltalk at: #CMRDictionary put: (Dictionary new). "set up user defined dictionary"
+CMRDictionary at: #MyVar1 put: 'hello1'. "put entry in dictionary"
+CMRDictionary add: #MyVar2->'hello2'. "add entry to dictionary use key->value combo"
+CMRDictionary size. "dictionary size"
+CMRDictionary keys do: [ :k | "print out keys in dictionary"
+ Transcript show: k printString; cr].
+CMRDictionary values do: [ :k | "print out values in dictionary"
+ Transcript show: k printString; cr].
+CMRDictionary keysAndValuesDo: [:aKey :aValue | "print out keys and values"
+ Transcript
+ show: aKey printString;
+ space;
+ show: aValue printString;
+ cr].
+CMRDictionary associationsDo: [:aKeyValue | "another iterator for printing key values"
+ Transcript show: aKeyValue printString; cr].
+Smalltalk removeKey: #CMRGlobal ifAbsent: []. "remove entry from Smalltalk dictionary"
+Smalltalk removeKey: #CMRDictionary ifAbsent: []. "remove user dictionary from Smalltalk dictionary"
+```
+
+## Internal Stream:
+```
+| b x ios |
+ios := ReadStream on: 'Hello read stream'.
+ios := ReadStream on: 'Hello read stream' from: 1 to: 5.
+[(x := ios nextLine) notNil]
+ whileTrue: [Transcript show: x; cr].
+ios position: 3.
+ios position.
+x := ios next.
+x := ios peek.
+x := ios contents.
+b := ios atEnd.
+
+ios := ReadWriteStream on: 'Hello read stream'.
+ios := ReadWriteStream on: 'Hello read stream' from: 1 to: 5.
+ios := ReadWriteStream with: 'Hello read stream'.
+ios := ReadWriteStream with: 'Hello read stream' from: 1 to: 10.
+ios position: 0.
+[(x := ios nextLine) notNil]
+ whileTrue: [Transcript show: x; cr].
+ios position: 6.
+ios position.
+ios nextPutAll: 'Chris'.
+x := ios next.
+x := ios peek.
+x := ios contents.
+b := ios atEnd.
+```
+
+## FileStream:
+```
+| b x ios |
+ios := FileStream newFileNamed: 'ios.txt'.
+ios nextPut: $H; cr.
+ios nextPutAll: 'Hello File'; cr.
+'Hello File' printOn: ios.
+'Hello File' storeOn: ios.
+ios close.
+
+ios := FileStream oldFileNamed: 'ios.txt'.
+[(x := ios nextLine) notNil]
+ whileTrue: [Transcript show: x; cr].
+ios position: 3.
+x := ios position.
+x := ios next.
+x := ios peek.
+b := ios atEnd.
+ios close.
+```
+
+## Date:
+```
+| x y |
+x := Date today. "create date for today"
+x := Date dateAndTimeNow. "create date from current time/date"
+x := Date readFromString: '01/02/1999'. "create date from formatted string"
+x := Date newDay: 12 month: #July year: 1999 "create date from parts"
+x := Date fromDays: 36000. "create date from elapsed days since 1/1/1901"
+y := Date dayOfWeek: #Monday. "day of week as int (1-7)"
+y := Date indexOfMonth: #January. "month of year as int (1-12)"
+y := Date daysInMonth: 2 forYear: 1996. "day of month as int (1-31)"
+y := Date daysInYear: 1996. "days in year (365|366)"
+y := Date nameOfDay: 1 "weekday name (#Monday,...)"
+y := Date nameOfMonth: 1. "month name (#January,...)"
+y := Date leapYear: 1996. "1 if leap year; 0 if not leap year"
+y := x weekday. "day of week (#Monday,...)"
+y := x previous: #Monday. "date for previous day of week"
+y := x dayOfMonth. "day of month (1-31)"
+y := x day. "day of year (1-366)"
+y := x firstDayOfMonth. "day of year for first day of month"
+y := x monthName. "month of year (#January,...)"
+y := x monthIndex. "month of year (1-12)"
+y := x daysInMonth. "days in month (1-31)"
+y := x year. "year (19xx)"
+y := x daysInYear. "days in year (365|366)"
+y := x daysLeftInYear. "days left in year (364|365)"
+y := x asSeconds. "seconds elapsed since 1/1/1901"
+y := x addDays: 10. "add days to date object"
+y := x subtractDays: 10. "subtract days to date object"
+y := x subtractDate: (Date today). "subtract date (result in days)"
+y := x printFormat: #(2 1 3 $/ 1 1). "print formatted date"
+b := (x <= Date today). "comparison"
+```
+
+## Time:
+```
+| x y |
+x := Time now. "create time from current time"
+x := Time dateAndTimeNow. "create time from current time/date"
+x := Time readFromString: '3:47:26 pm'. "create time from formatted string"
+x := Time fromSeconds: (60 * 60 * 4). "create time from elapsed time from midnight"
+y := Time millisecondClockValue. "milliseconds since midnight"
+y := Time totalSeconds. "total seconds since 1/1/1901"
+y := x seconds. "seconds past minute (0-59)"
+y := x minutes. "minutes past hour (0-59)"
+y := x hours. "hours past midnight (0-23)"
+y := x addTime: (Time now). "add time to time object"
+y := x subtractTime: (Time now). "subtract time to time object"
+y := x asSeconds. "convert time to seconds"
+x := Time millisecondsToRun: [ "timing facility"
+ 1 to: 1000 do: [:index | y := 3.14 * index]].
+b := (x <= Time now). "comparison"
+```
+
+## Point:
+```
+| x y |
+x := 200@100. "obtain a new point"
+y := x x. "x coordinate"
+y := x y. "y coordinate"
+x := 200@100 negated. "negates x and y"
+x := (-200@-100) abs. "absolute value of x and y"
+x := (200.5@100.5) rounded. "round x and y"
+x := (200.5@100.5) truncated. "truncate x and y"
+x := 200@100 + 100. "add scale to both x and y"
+x := 200@100 - 100. "subtract scale from both x and y"
+x := 200@100 * 2. "multiply x and y by scale"
+x := 200@100 / 2. "divide x and y by scale"
+x := 200@100 // 2. "divide x and y by scale"
+x := 200@100 \\ 3. "remainder of x and y by scale"
+x := 200@100 + 50@25. "add points"
+x := 200@100 - 50@25. "subtract points"
+x := 200@100 * 3@4. "multiply points"
+x := 200@100 // 3@4. "divide points"
+x := 200@100 max: 50@200. "max x and y"
+x := 200@100 min: 50@200. "min x and y"
+x := 20@5 dotProduct: 10@2. "sum of product (x1*x2 + y1*y2)"
+```
+
+## Rectangle:
+```
+Rectangle fromUser.
+```
+
+## Pen:
+```
+| myPen |
+Display restoreAfter: [
+ Display fillWhite.
+
+myPen := Pen new. "get graphic pen"
+myPen squareNib: 1.
+myPen color: (Color blue). "set pen color"
+myPen home. "position pen at center of display"
+myPen up. "makes nib unable to draw"
+myPen down. "enable the nib to draw"
+myPen north. "points direction towards top"
+myPen turn: -180. "add specified degrees to direction"
+myPen direction. "get current angle of pen"
+myPen go: 50. "move pen specified number of pixels"
+myPen location. "get the pen position"
+myPen goto: 200@200. "move to specified point"
+myPen place: 250@250. "move to specified point without drawing"
+myPen print: 'Hello World' withFont: (TextStyle default fontAt: 1).
+Display extent. "get display width@height"
+Display width. "get display width"
+Display height. "get display height"
+
+].
+```
+
+## Dynamic Message Calling/Compiling:
+```
+| receiver message result argument keyword1 keyword2 argument1 argument2 |
+"unary message"
+receiver := 5.
+message := 'factorial' asSymbol.
+result := receiver perform: message.
+result := Compiler evaluate: ((receiver storeString), ' ', message).
+result := (Message new setSelector: message arguments: #()) sentTo: receiver.
+
+"binary message"
+receiver := 1.
+message := '+' asSymbol.
+argument := 2.
+result := receiver perform: message withArguments: (Array with: argument).
+result := Compiler evaluate: ((receiver storeString), ' ', message, ' ', (argument storeString)).
+result := (Message new setSelector: message arguments: (Array with: argument)) sentTo: receiver.
+
+"keyword messages"
+receiver := 12.
+keyword1 := 'between:' asSymbol.
+keyword2 := 'and:' asSymbol.
+argument1 := 10.
+argument2 := 20.
+result := receiver
+ perform: (keyword1, keyword2) asSymbol
+ withArguments: (Array with: argument1 with: argument2).
+result := Compiler evaluate:
+ ((receiver storeString), ' ', keyword1, (argument1 storeString) , ' ', keyword2, (argument2 storeString)).
+result := (Message
+ new
+ setSelector: (keyword1, keyword2) asSymbol
+ arguments: (Array with: argument1 with: argument2))
+ sentTo: receiver.
+```
+
+## Class/Meta-class:
+```
+| b x |
+x := String name. "class name"
+x := String category. "organization category"
+x := String comment. "class comment"
+x := String kindOfSubclass. "subclass type - subclass: variableSubclass, etc"
+x := String definition. "class definition"
+x := String instVarNames. "immediate instance variable names"
+x := String allInstVarNames. "accumulated instance variable names"
+x := String classVarNames. "immediate class variable names"
+x := String allClassVarNames. "accumulated class variable names"
+x := String sharedPools. "immediate dictionaries used as shared pools"
+x := String allSharedPools. "accumulated dictionaries used as shared pools"
+x := String selectors. "message selectors for class"
+x := String sourceCodeAt: #size. "source code for specified method"
+x := String allInstances. "collection of all instances of class"
+x := String superclass. "immediate superclass"
+x := String allSuperclasses. "accumulated superclasses"
+x := String withAllSuperclasses. "receiver class and accumulated superclasses"
+x := String subclasses. "immediate subclasses"
+x := String allSubclasses. "accumulated subclasses"
+x := String withAllSubclasses. "receiver class and accumulated subclasses"
+b := String instSize. "number of named instance variables"
+b := String isFixed. "true if no indexed instance variables"
+b := String isVariable. "true if has indexed instance variables"
+b := String isPointers. "true if index instance vars contain objects"
+b := String isBits. "true if index instance vars contain bytes/words"
+b := String isBytes. "true if index instance vars contain bytes"
+b := String isWords. true if index instance vars contain words"
+Object withAllSubclasses size. "get total number of class entries"
+```
+
+## Debuging:
+```
+| a b x |
+x yourself. "returns receiver"
+String browse. "browse specified class"
+x inspect. "open object inspector window"
+x confirm: 'Is this correct?'.
+x halt. "breakpoint to open debugger window"
+x halt: 'Halt message'.
+x notify: 'Notify text'.
+x error: 'Error string'. "open up error window with title"
+x doesNotUnderstand: #cmrMessage. "flag message is not handled"
+x shouldNotImplement. "flag message should not be implemented"
+x subclassResponsibility. "flag message as abstract"
+x errorImproperStore. "flag an improper store into indexable object"
+x errorNonIntegerIndex. "flag only integers should be used as index"
+x errorSubscriptBounds. "flag subscript out of bounds"
+x primitiveFailed. "system primitive failed"
+
+a := 'A1'. b := 'B2'. a become: b. "switch two objects"
+Transcript show: a, b; cr.
+```
+
+## Misc
+```
+| x |
+"Smalltalk condenseChanges." "compress the change file"
+x := FillInTheBlank request: 'Prompt Me'. "prompt user for input"
+Utilities openCommandKeyHelp
+```
+
+
+
+
+## Ready For More?
+
+### Free Online
+
+* [GNU Smalltalk User's Guide](https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html)
+* [smalltalk dot org](http://www.smalltalk.org/smalltalk/learning.html)
+* [Computer Programming using GNU Smalltalk](http://www.canol.info/books/computer_programming_using_gnu_smalltalk/)
+* [Smalltalk Cheatsheet](http://www.angelfire.com/tx4/cus/notes/smalltalk.html)
+* [Smalltalk-72 Manual](http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf)
+* [BYTE: A Special issue on Smalltalk](https://archive.org/details/byte-magazine-1981-08)
+* [Smalltalk, Objects, and Design](https://books.google.co.in/books?id=W8_Une9cbbgC&printsec=frontcover&dq=smalltalk&hl=en&sa=X&ved=0CCIQ6AEwAWoVChMIw63Vo6CpyAIV0HGOCh3S2Alf#v=onepage&q=smalltalk&f=false)
+* [Smalltalk: An Introduction to Application Development Using VisualWorks](https://books.google.co.in/books?id=zalQAAAAMAAJ&q=smalltalk&dq=smalltalk&hl=en&sa=X&ved=0CCgQ6AEwAmoVChMIw63Vo6CpyAIV0HGOCh3S2Alf/)
diff --git a/swift.html.markdown b/swift.html.markdown
index 509c9d2f..86a0b89a 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -12,7 +12,7 @@ Swift is a programming language for iOS and OS X development created by Apple. D
The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.
+See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/), which has a complete tutorial on Swift.
```swift
// import a module
diff --git a/tcl.html.markdown b/tcl.html.markdown
index af2911c9..3982807f 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -356,7 +356,7 @@ eval $command ;# There is an error here, because there are too many arguments \
set replacement {Archibald Sorbisol}
set command {set name $replacement}
set command [subst $command]
-eval $command ;# The same error as before: to many arguments to "set" in \
+eval $command ;# The same error as before: too many arguments to "set" in \
{set name Archibald Sorbisol}
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index a68026a5..91c7c269 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -234,7 +234,8 @@ on a new line! ""Wow!"", the masses cried";
// Üçlü operatörler
// Basit bir if/else ifadesi şöyle yazılabilir
// ? :
- string isTrue = (true) ? "True" : "False";
+ int toCompare = 17;
+ string isTrue = toCompare == 17 ? "True" : "False";
// While döngüsü
int fooWhile = 0;
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 90f3fcd5..c13f5ecf 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -7,13 +7,10 @@ lang: tr-tr
---
Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir. Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
-
-The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
+
Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.
-
Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
@@ -244,7 +241,7 @@ print("Benzin fiyatı: \(fiyat)")
// Çeşitli Argümanlar
func ayarla(sayilar: Int...) {
- // its an array
+ // bu bir dizidir
let sayi = sayilar[0]
let argumanSAyisi = sayilar.count
}
diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown
index a3cda5b3..971c1be9 100644
--- a/zh-cn/csharp-cn.html.markdown
+++ b/zh-cn/csharp-cn.html.markdown
@@ -232,7 +232,8 @@ on a new line! ""Wow!"", the masses cried";
// 三元表达式
// 简单的 if/else 语句可以写成：
// <条件> ? <真> : <假>
- string isTrue = (true) ? "True" : "False";
+ int toCompare = 17;
+ string isTrue = toCompare == 17 ? "True" : "False";
// While 循环
int fooWhile = 0;
diff --git a/zh-cn/javascript-cn.html.markdown b/zh-cn/javascript-cn.html.markdown
index dfeb2012..bdef0099 100644
--- a/zh-cn/javascript-cn.html.markdown
+++ b/zh-cn/javascript-cn.html.markdown
@@ -447,9 +447,6 @@ myNumber === myNumberObj; // = false
if (0){
// 这段代码不会执行，因为0代表假
}
-if (Number(0)){
- // 这段代码*会*执行，因为Number(0)代表真
-}
// 不过，包装类型和内置类型共享一个原型，
// 所以你实际可以给内置类型也增加一些功能，例如对string：