diff options
270 files changed, 96358 insertions, 2046 deletions
diff --git a/README.markdown b/README.markdown index 77e09abd..774797d5 100644 --- a/README.markdown +++ b/README.markdown @@ -9,17 +9,73 @@ commented code and explained as they go. ... to write more inline code tutorials. Just grab an existing file from this repo and copy the formatting (don't worry, it's all very simple). Make a new file, send a pull request, and if it passes muster I'll get it up pronto. -Remember to fill in the author and author\_url fields so you get credited +Remember to fill in the "contributors" fields so you get credited properly! -### Requests +## Contributing -The most requested languages are: +All contributions are welcome, from the tiniest typo to a brand new article. Translations +in all languages are welcome (or, for that matter, original articles in any language). +Send a pull request or open an issue any time of day or night. -* Scala -* Javascript +**Please tag your issues pull requests with [language/lang-code] at the beginning** +**(e.g. [python/en] for English Python).** This will help everyone pick out things they +care about. -... but there are many more requests to do "every language", so don't let that stop you. +We're happy for any contribution in any form, but if you're making more than one major change +(i.e. translations for two different languages) it would be super cool of you to make a +separate pull request for each one so that someone can review them more effectively and/or +individually. + +### Style Guidelines + +* **Keep lines under 80 chars** +* **Prefer example to exposition** +* **Eschew surplusage** +* **Use UTF-8** + +Long version: + +* Try to keep **line length in code blocks to 80 characters or fewer**, or they'll overflow + and look odd. + +* Try to use as few words as possible. Code examples are preferred over exposition in all cases. + +* We welcome newcomers, but the target audience for this site is programmers with some experience. + So, try to avoid explaining basic concepts except for those specific to the language in question, + to keep articles succinct and scannable. We all know how to use Google here. + +* For translations (or English articles with non-ASCII characters), please make sure your file is + UTF-8 encoded, and try to leave out the byte-order-mark at the start of the file. (`:set nobomb` in Vim) + +### Header configuration + +The actual site uses Middleman to generate HTML files from these Markdown ones. Middleman, or at least +the custom scripts underpinning the site, required that some key information be defined in the header. + +The following fields are necessary for English articles about programming languages: + +* **language** The *programming language* in question +* **contributors** A list of [author, URL] lists to credit + +Other fields: + +* **filename**: The filename for this article's code. It will be fetched, mashed together, and made downloadable. + For non-English articles, *filename* should have a language-specific suffix. +* **lang**: For translations, the human language this article is in. For categorization, mostly. + +Here's an example header for an Esperanto translation of Ruby: + +```yaml +--- +language: ruby +filename: learnruby-epo.ruby +contributors: + - ["Doktor Esperanto", "http://example.com/"] + - ["Someone else", "http://someoneelseswebsite.com/"] +lang: ep-ep +--- +``` ## License diff --git a/amd.html.markdown b/amd.html.markdown new file mode 100644 index 00000000..d7fb41ba --- /dev/null +++ b/amd.html.markdown @@ -0,0 +1,212 @@ +---
+category: tool
+tool: amd
+contributors:
+ - ["Frederik Ring", "https://github.com/m90"]
+filename: learnamd.js
+---
+
+## Getting Started with AMD
+
+The **Asynchronous Module Definition** API specifies a mechanism for defining
+JavaScript modules such that the module and its dependencies can be asynchronously
+loaded. This is particularly well suited for the browser environment where
+synchronous loading of modules incurs performance, usability, debugging, and
+cross-domain access problems.
+
+### Basic concept
+```javascript
+// The basic AMD API consists of nothing but two methods: `define` and `require`
+// and is all about module definition and consumption:
+// `define(id?, dependencies?, factory)` defines a module
+// `require(dependencies, callback)` imports a set of dependencies and
+// consumes them in the passed callback
+
+// Let's start by using define to define a new named module
+// that has no dependencies. We'll do so by passing a name
+// and a factory function to define:
+define('awesomeAMD', function(){
+ var isAMDAwesome = function(){
+ return true;
+ };
+ // The return value of a module's factory function is
+ // what other modules or require calls will receive when
+ // requiring our `awesomeAMD` module.
+ // The exported value can be anything, (constructor) functions,
+ // objects, primitives, even undefined (although that won't help too much).
+ return isAMDAwesome;
+});
+
+// Now, let's define another module that depends upon our `awesomeAMD` module.
+// Notice that there's an additional argument defining our
+// module's dependencies now:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+ // dependencies will be passed to the factory's arguments
+ // in the order they are specified
+ var tellEveryone = function(){
+ if (awesomeAMD()){
+ alert('This is sOoOo rad!');
+ } else {
+ alert('Pretty dull, isn\'t it?');
+ }
+ };
+ return tellEveryone;
+});
+
+// As we do know how to use define now, let's use `require` to
+// kick off our program. `require`'s signature is `(arrayOfDependencies, callback)`.
+require(['loudmouth'], function(loudmouth){
+ loudmouth();
+});
+
+// To make this tutorial run code, let's implement a very basic
+// (non-asynchronous) version of AMD right here on the spot:
+function define(name, deps, factory){
+ // notice how modules without dependencies are handled
+ define[name] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+ var args = [];
+ // first let's retrieve all the dependencies needed
+ // by the require call
+ for (var i = 0; i < deps.length; i++){
+ args[i] = define[deps[i]];
+ }
+ // satisfy all the callback's dependencies
+ return callback.apply(null, args);
+}
+// you can see this code in action here: http://jsfiddle.net/qap949pd/
+```
+
+### Real-world usage with require.js
+
+In contrast to the introductory example, `require.js` (the most popular AMD library) actually implements the **A** in **AMD**, enabling you to load modules and their dependencies asynchronously via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/someClass'], function(SomeClass){
+ // the callback is deferred until the dependency is loaded
+ var thing = new SomeClass();
+});
+console.log('So here we are, waiting!'); // this will run first
+```
+
+By convention, you usually store one module in one file. `require.js` can resolve module names based on file paths, so you don't have to name your modules, but can simply reference them using their location. In the example `someClass` is assumed to be in the `modules` folder, relative to your configuration's `baseUrl`:
+
+* app/
+ * main.js
+ * modules/
+ * someClass.js
+ * someHelpers.js
+ * ...
+ * daos/
+ * things.js
+ * ...
+
+This means we can define `someClass` without specifying a module id:
+
+```javascript
+/* file: app/modules/someClass.js */
+define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
+ // module definition, of course, will also happen asynchronously
+ function SomeClass(){
+ this.method = function(){/**/};
+ // ...
+ }
+ return SomeClass;
+});
+```
+To alter the default path mapping behavior use `requirejs.config(configObj)` in your `main.js`:
+
+```javascript
+/* file: main.js */
+requirejs.config({
+ baseUrl : 'app',
+ paths : {
+ // you can also load modules from other locations
+ jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+ coolLibFromBower : '../bower_components/cool-lib/coollib'
+ }
+});
+require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
+ // a `main` file needs to call require at least once,
+ // otherwise no code will ever run
+ coolLib.doFancyStuffWith(helpers.transform($('#foo')));
+});
+```
+`require.js`-based apps will usually have a single entry point (`main.js`) that is passed to the `require.js` script tag as a data-attribute. It will be automatically loaded and executed on pageload:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+ <title>A hundred script tags? Never again!</title>
+</head>
+<body>
+ <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### Optimizing a whole project using r.js
+
+Many people prefer using AMD for sane code organization during development, but still want to ship a single script file in production instead of performing hundreds of XHRs on page load.
+
+`require.js` comes with a script called `r.js` (that you will probably run in node.js, although Rhino is supported too) that can analyse your project's dependency graph, and build a single file containing all your modules (properly named), minified and ready for consumption.
+
+Install it using `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+Now you can feed it with a configuration file:
+```shell
+$ r.js -o app.build.js
+```
+
+For our above example the configuration might look like:
+```javascript
+/* file : app.build.js */
+({
+ name : 'main', // name of the entry point
+ out : 'main-built.js', // name of the file to write the output to
+ baseUrl : 'app',
+ paths : {
+ // `empty:` tells r.js that this should still be loaded from the CDN, using
+ // the location specified in `main.js`
+ jquery : 'empty:',
+ coolLibFromBower : '../bower_components/cool-lib/coollib'
+ }
+})
+```
+
+To use the built file in production, simply swap `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+An incredibly detailed [overview of build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is available in the GitHub repo.
+
+### Topics not covered in this tutorial
+* [Loader plugins / transforms](http://requirejs.org/docs/plugins.html)
+* [CommonJS style loading and exporting](http://requirejs.org/docs/commonjs.html)
+* [Advanced configuration](http://requirejs.org/docs/api.html#config)
+* [Shim configuration (loading non-AMD modules)](http://requirejs.org/docs/api.html#config-shim)
+* [CSS loading and optimizing with require.js](http://requirejs.org/docs/optimization.html#onecss)
+* [Using almond.js for builds](https://github.com/jrburke/almond)
+
+### Further reading:
+
+* [Official Spec](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [Why AMD?](http://requirejs.org/docs/whyamd.html)
+* [Universal Module Definition](https://github.com/umdjs/umd)
+
+### Implementations:
+
+* [require.js](http://requirejs.org)
+* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [cujo.js](http://cujojs.com/)
+* [curl.js](https://github.com/cujojs/curl)
+* [lsjs](https://github.com/zazl/lsjs)
+* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown new file mode 100644 index 00000000..a516737e --- /dev/null +++ b/asymptotic-notation.html.markdown @@ -0,0 +1,139 @@ +--- +category: Algorithms & Data Structures +name: Asymptotic Notation +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +--- + +# Asymptotic Notations + +## What are they? + +Asymptotic Notations are languages that allow us to analyze an algorithm's running time by +identifying its behavior as the input size for the algorithm increases. This is also known as +an algorithm's growth rate. Does the algorithm suddenly become incredibly slow when the input +size grows? Does it mostly maintain its quick run time as the input size increases? +Asymptotic Notation gives us the ability to answer these questions. + +## Are there alternatives to answering these questions? + +One way would be to count the number of primitive operations at different input sizes. +Though this is a valid solution, the amount of work this takes for even simple algorithms +does not justify its use. + +Another way is to physically measure the amount of time an algorithm takes to complete +given different input sizes. However, the accuracy and relativity (times obtained would +only be relative to the machine they were computed on) of this method is bound to +environmental variables such as computer hardware specifications, processing power, etc. + +## Types of Asymptotic Notation + +In the first section of this doc we described how an Asymptotic Notation identifies the +behavior of an algorithm as the input size changes. Let us imagine an algorithm as a function +f, n as the input size, and f(n) being the running time. So for a given algorithm f, with input +size n you get some resultant run time f(n). This results in a graph where the Y axis is the +runtime, X axis is the input size, and plot points are the resultants of the amount of time +for a given input size. + +You can label a function, or algorithm, with an Asymptotic Notation in many different ways. +Some examples are, you can describe an algorithm by its best case, worse case, or equivalent case. +The most common is to analyze an algorithm by its worst case. You typically don't evaluate by best case because those conditions aren't what you're planning for. A very good example of this is sorting algorithms; specifically, adding elements to a tree structure. Best case for most algorithms could be as low as a single operation. However, in most cases, the element you're adding will need to be sorted appropriately through the tree, which could mean examining an entire branch. This is the worst case, and this is what we plan for. + +### Types of functions, limits, and simplification + +``` +Logarithmic Function - log n +Linear Function - an + b +Quadratic Function - an^2 + bn + c +Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some constant +Exponential Function - a^n, where a is some constant +``` + +These are some basic function growth classifications used in various notations. The list starts at the slowest growing function (logarithmic, fastest execution time) and goes on to the fastest growing (exponential, slowest execution time). Notice that as 'n', or the input, increases in each of those functions, the result clearly increases much quicker in quadratic, polynomial, and exponential, compared to logarithmic and linear. + +One extremely important note is that for the notations about to be discussed you should do your best to use simplest terms. This means to disregard constants, and lower order terms, because as the input size (or n in our f(n) +example) increases to infinity (mathematical limits), the lower order terms and constants are of little +to no importance. That being said, if you have constants that are 2^9001, or some other ridiculous, +unimaginable amount, realize that simplifying will skew your notation accuracy. + +Since we want simplest form, lets modify our table a bit... + +``` +Logarithmic - log n +Linear - n +Quadratic - n^2 +Polynomial - n^z, where z is some constant +Exponential - a^n, where a is some constant +``` + +### Big-O +Big-O, commonly written as O, is an Asymptotic Notation for the worst case, or ceiling of growth +for a given function. Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time complexity +you are trying to relate to your algorithm. `f(n)` is O(g(n)), if for any real constant c (c > 0), +`f(n)` <= `c g(n)` for every input size n (n > 0). + +*Example 1* + +``` +f(n) = 3log n + 100 +g(n) = log n +``` + +Is `f(n)` O(g(n))? +Is `3 log n + 100` O(log n)? +Let's look to the definition of Big-O. + +``` +3log n + 100 <= c * log n +``` + +Is there some constant c that satisfies this for all n? + +``` +3log n + 100 <= 150 * log n, n > 2 (undefined at n = 1) +``` + +Yes! The definition of Big-O has been met therefore `f(n)` is O(g(n)). + +*Example 2* + +``` +f(n) = 3*n^2 +g(n) = n +``` + +Is `f(n)` O(g(n))? +Is `3 * n^2` O(n)? +Let's look at the definition of Big-O. + +``` +3 * n^2 <= c * n +``` + +Is there some constant c that satisfies this for all n? +No, there isn't. `f(n)` is NOT O(g(n)). + +### Big-Omega +Big-Omega, commonly written as Ω, is an Asymptotic Notation for the best case, or a floor growth rate +for a given function. + +`f(n)` is Ω(g(n)), if for any real constant c (c > 0), `f(n)` is >= `c g(n)` for every input size n (n > 0). + +Feel free to head over to additional resources for examples on this. Big-O is the primary notation used +for general algorithm time complexity. + +### Ending Notes +It's hard to keep this kind of topic short, and you should definitely go through the books and online +resources listed. They go into much greater depth with definitions and examples. +More where x='Algorithms & Data Structures' is on its way; we'll have a doc up on analyzing actual +code examples soon. + +## Books + +* [Algorithms](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X) +* [Algorithm Design](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651) + +## Online Resources + +* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf) +* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation) diff --git a/bash.html.markdown b/bash.html.markdown new file mode 100644 index 00000000..191f916a --- /dev/null +++ b/bash.html.markdown @@ -0,0 +1,282 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] + - ["Etan Reisner", "https://github.com/deryni"] +filename: LearnBash.sh +--- + +Bash is a name of the unix shell, which was also distributed as the shell for the GNU operating system and as default shell on Linux and Mac OS X. +Nearly all examples below can be a part of a shell script or executed directly in the shell. + +[Read more here.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# First line of the script is shebang which tells the system how to execute +# the script: http://en.wikipedia.org/wiki/Shebang_(Unix) +# As you already figured, comments start with #. Shebang is also a comment. + +# Simple hello world example: +echo Hello world! + +# Each command starts on a new line, or after semicolon: +echo 'This is the first line'; echo 'This is the second line' + +# Declaring a variable looks like this: +Variable="Some string" + +# But not like this: +Variable = "Some string" +# Bash will decide that Variable is a command it must execute and give an error +# because it can't be found. + +# Or like this: +Variable= 'Some string' +# Bash will decide that 'Some string' is a command it must execute and give an +# error because it can't be found. (In this case the 'Variable=' part is seen +# as a variable assignment valid only for the scope of the 'Some string' +# command.) + +# Using the variable: +echo $Variable +echo "$Variable" +echo '$Variable' +# When you use the variable itself — assign it, export it, or else — you write +# its name without $. If you want to use the variable's value, you should use $. +# Note that ' (single quote) won't expand the variables! + +# String substitution in variables +echo ${Variable/Some/A} +# This will substitute the first occurrence of "Some" with "A" + +# Substring from a variable +Length=7 +echo ${Variable:0:Length} +# This will return only the first 7 characters of the value + +# Default value for variable +echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"} +# This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0. +# Note that it only returns default value and doesn't change variable value. + +# Builtin variables: +# There are some useful builtin variables, like +echo "Last program's return value: $?" +echo "Script's PID: $$" +echo "Number of arguments passed to script: $#" +echo "All arguments passed to script: $@" +echo "Script's arguments separated into different variables: $1 $2..." + +# Reading a value from input: +echo "What's your name?" +read Name # Note that we didn't need to declare a new variable +echo Hello, $Name! + +# We have the usual if structure: +# use 'man test' for more info about conditionals +if [ $Name -ne $USER ] +then + echo "Your name isn't your username" +else + echo "Your name is your username" +fi + +# There is also conditional execution +echo "Always executed" || echo "Only executed if first command fails" +echo "Always executed" && echo "Only executed if first command does NOT fail" + +# To use && and || with if statements, you need multiple pairs of square brackets: +if [ $Name == "Steve" ] && [ $Age -eq 15 ] +then + echo "This will run if $Name is Steve AND $Age is 15." +fi + +if [ $Name == "Daniya" ] || [ $Name == "Zach" ] +then + echo "This will run if $Name is Daniya OR Zach." +fi + +# Expressions are denoted with the following format: +echo $(( 10 + 5 )) + +# Unlike other programming languages, bash is a shell so it works in the context +# of a current directory. You can list files and directories in the current +# directory with the ls command: +ls + +# These commands have options that control their execution: +ls -l # Lists every file and directory on a separate line + +# Results of the previous command can be passed to the next command as input. +# grep command filters the input with provided patterns. That's how we can list +# .txt files in the current directory: +ls -l | grep "\.txt" + +# You can redirect command input and output (stdin, stdout, and stderr). +# Read from stdin until ^EOF$ and overwrite hello.py with the lines +# between "EOF": +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Run hello.py with various stdin, stdout, and stderr redirections: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# The output error will overwrite the file if it exists, +# if you want to append instead, use ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Overwrite output.out, append to error.err, and count lines: +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Run a command and print its file descriptor (e.g. /dev/fd/123) +# see: man fd +echo <(echo "#helloworld") + +# Overwrite output.out with "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Cleanup temporary files verbosely (add '-i' for interactive) +rm -v output.out error.err output-and-error.log + +# Commands can be substituted within other commands using $( ): +# The following command displays the number of files and directories in the +# current directory. +echo "There are $(ls | wc -l) items here." + +# The same can be done using backticks `` but they can't be nested - the preferred way +# is to use $( ). +echo "There are `ls | wc -l` items here." + +# Bash uses a case statement that works similarly to switch in Java and C++: +case "$Variable" in + #List patterns for the conditions you want to meet + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# for loops iterate for as many arguments given: +# The contents of $Variable is printed three times. +for Variable in {1..3} +do + echo "$Variable" +done + +# Or write it the "traditional for loop" way: +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# They can also be used to act on files.. +# This will run the command 'cat' on file1 and file2 +for Variable in file1 file2 +do + cat "$Variable" +done + +# ..or the output from a command +# This will cat the output from ls. +for Output in $(ls) +do + cat "$Output" +done + +# while loop: +while [ true ] +do + echo "loop body here..." + break +done + +# You can also define functions +# Definition: +function foo () +{ + echo "Arguments work just like script arguments: $@" + echo "And: $1 $2..." + echo "This is a function" + return 0 +} + +# or simply +bar () +{ + echo "Another way to declare functions!" + return 0 +} + +# Calling your function +foo "My name is" $Name + +# There are a lot of useful commands you should learn: +# prints last 10 lines of file.txt +tail -n 10 file.txt +# prints first 10 lines of file.txt +head -n 10 file.txt +# sort file.txt's lines +sort file.txt +# report or omit repeated lines, with -d it reports them +uniq -d file.txt +# prints only the first column before the ',' character +cut -d ',' -f 1 file.txt +# replaces every occurrence of 'okay' with 'great' in file.txt, (regex compatible) +sed -i 's/okay/great/g' file.txt +# print to stdout all lines of file.txt which match some regex +# The example prints lines which begin with "foo" and end in "bar" +grep "^foo.*bar$" file.txt +# pass the option "-c" to instead print the number of lines matching the regex +grep -c "^foo.*bar$" file.txt +# if you literally want to search for the string, +# and not the regex, use fgrep (or grep -F) +fgrep "^foo.*bar$" file.txt + + +# Read Bash shell builtins documentation with the bash 'help' builtin: +help +help help +help for +help return +help source +help . + +# Read Bash manpage documentation with man +apropos bash +man 1 bash +man bash + +# Read info documentation with info (? for help) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Read bash info documentation: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/brainfuck.html.markdown b/brainfuck.html.markdown new file mode 100644 index 00000000..a76169c8 --- /dev/null +++ b/brainfuck.html.markdown @@ -0,0 +1,81 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +--- + +Brainfuck (not capitalized except at the start of a sentence) is an extremely +minimal Turing-complete programming language with just 8 commands. + +You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). + +``` +Any character not "><+-.,[]" (excluding quotation marks) is ignored. + +Brainfuck is represented by an array with 30,000 cells initialized to zero +and a data pointer pointing at the current cell. + +There are eight commands: ++ : Increments the value at the current cell by one. +- : Decrements the value at the current cell by one. +> : Moves the data pointer to the next cell (cell on the right). +< : Moves the data pointer to the previous cell (cell on the left). +. : Prints the ASCII value at the current cell (i.e. 65 = 'A'). +, : Reads a single input character into the current cell. +[ : If the value at the current cell is zero, skips to the corresponding ] . + Otherwise, move to the next instruction. +] : If the value at the current cell is zero, move to the next instruction. + Otherwise, move backwards in the instructions to the corresponding [ . + +[ and ] form a while loop. Obviously, they must be balanced. + +Let's look at some basic brainfuck programs. + +++++++ [ > ++++++++++ < - ] > +++++ . + +This program prints out the letter 'A'. First, it increments cell #1 to 6. +Cell #1 will be used for looping. Then, it enters the loop ([) and moves +to cell #2. It increments cell #2 10 times, moves back to cell #1, and +decrements cell #1. This loop happens 6 times (it takes 6 decrements for +cell #1 to reach 0, at which point it skips to the corresponding ] and +continues on). + +At this point, we're on cell #1, which has a value of 0, while cell #2 has a +value of 60. We move on cell #2, increment 5 times, for a value of 65, and then +print cell #2's value. 65 is 'A' in ASCII, so 'A' is printed to the terminal. + + +, [ > + < - ] > . + +This program reads a character from the user input and copies the character into +cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2, +move back to cell #1, and decrement the value at cell #1. This continues on +until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on +cell #1 at the end of the loop, move to cell #2, and then print out the value +in ASCII. + +Also keep in mind that the spaces are purely for readability purposes. You +could just as easily write it as: + +,[>+<-]>. + +Try and figure out what this program does: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +This program takes two numbers for input, and multiplies them. + +The gist is it first reads in two inputs. Then it starts the outer loop, +conditioned on cell #1. Then it moves to cell #2, and starts the inner +loop conditioned on cell #2, incrementing cell #3. However, there comes a +problem: At the end of the inner loop, cell #2 is zero. In that case, +inner loop won't work anymore since next time. To solve this problem, +we also increment cell #4, and then recopy cell #4 into cell #2. +Then cell #3 is the result. +``` + +And that's brainfuck. Not that hard, eh? For fun, you can write your own +brainfuck programs, or you can write a brainfuck interpreter in another +language. The interpreter is fairly simple to implement, but if you're a +masochist, try writing a brainfuck interpreter… in brainfuck. diff --git a/c++.html.markdown b/c++.html.markdown new file mode 100644 index 00000000..6f4d0562 --- /dev/null +++ b/c++.html.markdown @@ -0,0 +1,810 @@ +--- +language: c++ +filename: learncpp.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Connor Waters", "http://github.com/connorwaters"] +lang: en +--- + +C++ is a systems programming language that, +[according to its inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +was designed to + +- be a "better C" +- support data abstraction +- support object-oriented programming +- support generic programming + +Though its syntax can be more difficult or complex than newer languages, +it is widely used because it compiles to native instructions that can be +directly run by the processor and offers tight control over hardware (like C) +while offering high-level features such as generics, exceptions, and classes. +This combination of speed and functionality makes C++ +one of the most widely-used programming languages. + +```c++ +////////////////// +// Comparison to C +////////////////// + +// C++ is _almost_ a superset of C and shares its basic syntax for +// variable declarations, primitive types, and functions. + +// Just like in C, your program's entry point is a function called +// main with an integer return type. +// This value serves as the program's exit status. +// See http://en.wikipedia.org/wiki/Exit_status for more information. +int main(int argc, char** argv) +{ + // Command line arguments are passed in by argc and argv in the same way + // they are in C. + // argc indicates the number of arguments, + // and argv is an array of C-style strings (char*) + // representing the arguments. + // The first argument is the name by which the program was called. + // argc and argv can be omitted if you do not care about arguments, + // giving the function signature of int main() + + // An exit status of 0 indicates success. + return 0; +} + +// However, C++ varies in some of the following ways: + +// In C++, character literals are chars +sizeof('c') == sizeof(char) == 1 + +// In C, character literals are ints +sizeof('c') == sizeof(int) + + +// C++ has strict prototyping +void func(); // function which accepts no arguments + +// In C +void func(); // function which may accept any number of arguments + +// Use nullptr instead of NULL in C++ +int* ip = nullptr; + +// C standard headers are available in C++, +// but are prefixed with "c" and have no .h suffix. +#include <cstdio> + +int main() +{ + printf("Hello, world!\n"); + return 0; +} + +/////////////////////// +// Function overloading +/////////////////////// + +// C++ supports function overloading +// provided each function takes different parameters. + +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("My int is %d", myInt); +} + +int main() +{ + print("Hello"); // Resolves to void print(const char*) + print(15); // Resolves to void print(int) +} + +///////////////////////////// +// Default function arguments +///////////////////////////// + +// You can provide default arguments for a function +// if they are not provided by the caller. + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // Do something with the ints here +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Default arguments must be at the end of the arguments list. + +void invalidDeclaration(int a = 1, int b) // Error! +{ +} + + +///////////// +// Namespaces +///////////// + +// Namespaces provide separate scopes for variable, function, +// and other declarations. +// Namespaces can be nested. + +namespace First { + namespace Nested { + void foo() + { + printf("This is First::Nested::foo\n"); + } + } // end namespace Nested +} // end namespace First + +namespace Second { + void foo() + { + printf("This is Second::foo\n") + } +} + +void foo() +{ + printf("This is global foo\n"); +} + +int main() +{ + // Includes all symbols from namespace Second into the current scope. Note + // that simply foo() no longer works, since it is now ambiguous whether + // we're calling the foo in namespace Second or the top level. + using namespace Second; + + Second::foo(); // prints "This is Second::foo" + First::Nested::foo(); // prints "This is First::Nested::foo" + ::foo(); // prints "This is global foo" +} + +/////////////// +// Input/Output +/////////////// + +// C++ input and output uses streams +// cin, cout, and cerr represent stdin, stdout, and stderr. +// << is the insertion operator and >> is the extraction operator. + +#include <iostream> // Include for I/O streams + +using namespace std; // Streams are in the std namespace (standard library) + +int main() +{ + int myInt; + + // Prints to stdout (or terminal/screen) + cout << "Enter your favorite number:\n"; + // Takes in input + cin >> myInt; + + // cout can also be formatted + cout << "Your favorite number is " << myInt << "\n"; + // prints "Your favorite number is <myInt>" + + cerr << "Used for error messages"; +} + +////////// +// Strings +////////// + +// Strings in C++ are objects and have many member functions +#include <string> + +using namespace std; // Strings are also in the namespace std (standard library) + +string myString = "Hello"; +string myOtherString = " World"; + +// + is used for concatenation. +cout << myString + myOtherString; // "Hello World" + +cout << myString + " You"; // "Hello You" + +// C++ strings are mutable and have value semantics. +myString.append(" Dog"); +cout << myString; // "Hello Dog" + + +///////////// +// References +///////////// + +// In addition to pointers like the ones in C, +// C++ has _references_. +// These are pointer types that cannot be reassigned once set +// and cannot be null. +// They also have the same syntax as the variable itself: +// No * is needed for dereferencing and +// & (address of) is not used for assignment. + +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // This creates a reference to foo. +fooRef += ". Hi!"; // Modifies foo through the reference +cout << fooRef; // Prints "I am foo. Hi!" + +// Doesn't reassign "fooRef". This is the same as "foo = bar", and +// foo == "I am bar" +// after this line. +cout << &fooRef << endl; //Prints the address of foo +fooRef = bar; +cout << &fooRef << endl; //Still prints the address of foo +cout << fooRef; // Prints "I am bar" + +//The address of fooRef remains the same, i.e. it is still referring to foo. + + +const string& barRef = bar; // Create a const reference to bar. +// Like C, const values (and pointers and references) cannot be modified. +barRef += ". Hi!"; // Error, const references cannot be modified. + +// Sidetrack: Before we talk more about references, we must introduce a concept +// called a temporary object. Suppose we have the following code: +string tempObjectFun() { ... } +string retVal = tempObjectFun(); + +// What happens in the second line is actually: +// - a string object is returned from tempObjectFun +// - a new string is constructed with the returned object as argument to the +// constructor +// - the returned object is destroyed +// The returned object is called a temporary object. Temporary objects are +// created whenever a function returns an object, and they are destroyed at the +// end of the evaluation of the enclosing expression (Well, this is what the +// standard says, but compilers are allowed to change this behavior. Look up +// "return value optimization" if you're into this kind of details). So in this +// code: +foo(bar(tempObjectFun())) + +// assuming foo and bar exist, the object returned from tempObjectFun is +// passed to bar, and it is destroyed before foo is called. + +// Now back to references. The exception to the "at the end of the enclosing +// expression" rule is if a temporary object is bound to a const reference, in +// which case its life gets extended to the current scope: + +void constReferenceTempObjectFun() { + // constRef gets the temporary object, and it is valid until the end of this + // function. + const string& constRef = tempObjectFun(); + ... +} + +// Another kind of reference introduced in C++11 is specifically for temporary +// objects. You cannot have a variable of its type, but it takes precedence in +// overload resolution: + +void someFun(string& s) { ... } // Regular reference +void someFun(string&& s) { ... } // Reference to temporary object + +string foo; +someFun(foo); // Calls the version with regular reference +someFun(tempObjectFun()); // Calls the version with temporary reference + +// For example, you will see these two versions of constructors for +// std::basic_string: +basic_string(const basic_string& other); +basic_string(basic_string&& other); + +// Idea being if we are constructing a new string from a temporary object (which +// is going to be destroyed soon anyway), we can have a more efficient +// constructor that "salvages" parts of that temporary string. You will see this +// concept referred to as "move semantics". + +////////////////////////////////////////// +// Classes and object-oriented programming +////////////////////////////////////////// + +// First example of classes +#include <iostream> + +// Declare a class. +// Classes are usually declared in header (.h or .hpp) files. +class Dog { + // Member variables and functions are private by default. + std::string name; + int weight; + +// All members following this are public +// until "private:" or "protected:" is found. +public: + + // Default constructor + Dog(); + + // Member function declarations (implementations to follow) + // Note that we use std::string here instead of placing + // using namespace std; + // above. + // Never put a "using namespace" statement in a header. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Functions that do not modify the state of the object + // should be marked as const. + // This allows you to call them if given a const reference to the object. + // Also note the functions must be explicitly declared as _virtual_ + // in order to be overridden in derived classes. + // Functions are not virtual by default for performance reasons. + virtual void print() const; + + // Functions can also be defined inside the class body. + // Functions defined as such are automatically inlined. + void bark() const { std::cout << name << " barks!\n"; } + + // Along with constructors, C++ provides destructors. + // These are called when an object is deleted or falls out of scope. + // This enables powerful paradigms such as RAII + // (see below) + // The destructor should be virtual if a class is to be derived from; + // if it is not virtual, then the derived class' destructor will + // not be called if the object is destroyed through a base-class reference + // or pointer. + virtual ~Dog(); + +}; // A semicolon must follow the class definition. + +// Class member functions are usually implemented in .cpp files. +Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objects (such as strings) should be passed by reference +// if you are modifying them or const reference if you are not. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Notice that "virtual" is only needed in the declaration, not the definition. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +Dog::~Dog() +{ + cout << "Goodbye " << name << "\n"; +} + +int main() { + Dog myDog; // prints "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.print(); // prints "Dog is Barkley and weighs 10 kg" + return 0; +} // prints "Goodbye Barkley" + +// Inheritance: + +// This class inherits everything public and protected from the Dog class +class OwnedDog : public Dog { + + void setOwner(const std::string& dogsOwner); + + // Override the behavior of the print function for all OwnedDogs. See + // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // for a more general introduction if you are unfamiliar with + // subtype polymorphism. + // The override keyword is optional but makes sure you are actually + // overriding the method in a base class. + void print() const override; + +private: + std::string owner; +}; + +// Meanwhile, in the corresponding .cpp file: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Call the print function in the base Dog class + std::cout << "Dog is owned by " << owner << "\n"; + // Prints "Dog is <name> and weights <weight>" + // "Dog is owned by <owner>" +} + +////////////////////////////////////////// +// Initialization and Operator Overloading +////////////////////////////////////////// + +// In C++ you can overload the behavior of operators such as +, -, *, /, etc. +// This is done by defining a function which is called +// whenever the operator is used. + +#include <iostream> +using namespace std; + +class Point { +public: + // Member variables can be given default values in this manner. + double x = 0; + double y = 0; + + // Define a default constructor which does nothing + // but initialize the Point to the default value (0, 0) + Point() { }; + + // The following syntax is known as an initialization list + // and is the proper way to initialize class member values + Point (double a, double b) : + x(a), + y(b) + { /* Do nothing except initialize the values */ } + + // Overload the + operator. + Point operator+(const Point& rhs) const; + + // Overload the += operator + Point& operator+=(const Point& rhs); + + // It would also make sense to add the - and -= operators, + // but we will skip those for brevity. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Create a new point that is the sum of this one and rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // This calls the Point + operator + // Point up calls the + (function) with right as its parameter + Point result = up + right; + // Prints "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +///////////////////// +// Templates +///////////////////// + +// Templates in C++ are mostly used for generic programming, though they are +// much more powerful than generic constructs in other languages. They also +// support explicit and partial specialization and functional-style type +// classes; in fact, they are a Turing-complete functional language embedded +// in C++! + +// We start with the kind of generic programming you might be familiar with. To +// define a class or function that takes a type parameter: +template<class T> +class Box { +public: + // In this class, T can be used as any other type. + void insert(const T&) { ... } +}; + +// During compilation, the compiler actually generates copies of each template +// with parameters substituted, so the full definition of the class must be +// present at each invocation. This is why you will see template classes defined +// entirely in header files. + +// To instantiate a template class on the stack: +Box<int> intBox; + +// and you can use it as you would expect: +intBox.insert(123); + +// You can, of course, nest templates: +Box<Box<int> > boxOfBox; +boxOfBox.insert(intBox); + +// Until C++11, you had to place a space between the two '>'s, otherwise '>>' +// would be parsed as the right shift operator. + +// You will sometimes see +// template<typename T> +// instead. The 'class' keyword and 'typename' keywords are _mostly_ +// interchangeable in this case. For the full explanation, see +// http://en.wikipedia.org/wiki/Typename +// (yes, that keyword has its own Wikipedia page). + +// Similarly, a template function: +template<class T> +void barkThreeTimes(const T& input) +{ + input.bark(); + input.bark(); + input.bark(); +} + +// Notice that nothing is specified about the type parameters here. The compiler +// will generate and then type-check every invocation of the template, so the +// above function works with any type 'T' that has a const 'bark' method! + +Dog fluffy; +fluffy.setName("Fluffy") +barkThreeTimes(fluffy); // Prints "Fluffy barks" three times. + +// Template parameters don't have to be classes: +template<int Y> +void printMessage() { + cout << "Learn C++ in " << Y << " minutes!" << endl; +} + +// And you can explicitly specialize templates for more efficient code. Of +// course, most real-world uses of specialization are not as trivial as this. +// Note that you still need to declare the function (or class) as a template +// even if you explicitly specified all parameters. +template<> +void printMessage<10>() { + cout << "Learn C++ faster in only 10 minutes!" << endl; +} + +printMessage<20>(); // Prints "Learn C++ in 20 minutes!" +printMessage<10>(); // Prints "Learn C++ faster in only 10 minutes!" + + +///////////////////// +// Exception Handling +///////////////////// + +// The standard library provides a few exception types +// (see http://en.cppreference.com/w/cpp/error/exception) +// but any type can be thrown an as exception +#include <exception> +#include <stdexcept> + +// All exceptions thrown inside the _try_ block can be caught by subsequent +// _catch_ handlers. +try { + // Do not allocate exceptions on the heap using _new_. + throw std::runtime_error("A problem occurred"); +} + +// Catch exceptions by const reference if they are objects +catch (const std::exception& ex) +{ + std::cout << ex.what(); +} + +// Catches any exception not caught by previous _catch_ blocks +catch (...) +{ + std::cout << "Unknown exception caught"; + throw; // Re-throws the exception +} + +/////// +// RAII +/////// + +// RAII stands for "Resource Acquisition Is Initialization". +// It is often considered the most powerful paradigm in C++ +// and is the simple concept that a constructor for an object +// acquires that object's resources and the destructor releases them. + +// To understand how this is useful, +// consider a function that uses a C file handle: +void doSomethingWithAFile(const char* filename) +{ + // To begin with, assume nothing can fail. + + FILE* fh = fopen(filename, "r"); // Open the file in read mode. + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Close the file handle. +} + +// Unfortunately, things are quickly complicated by error handling. +// Suppose fopen can fail, and that doSomethingWithTheFile and +// doSomethingElseWithIt return error codes if they fail. +// (Exceptions are the preferred way of handling failure, +// but some programmers, especially those with a C background, +// disagree on the utility of exceptions). +// We now have to check each call for failure and close the file handle +// if a problem occurred. +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Open the file in read mode + if (fh == nullptr) // The returned pointer is null on failure. + return false; // Report that failure to the caller. + + // Assume each function returns false if it failed + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Close the file handle so it doesn't leak. + return false; // Propagate the error. + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Close the file handle so it doesn't leak. + return false; // Propagate the error. + } + + fclose(fh); // Close the file handle so it doesn't leak. + return true; // Indicate success +} + +// C programmers often clean this up a little bit using goto: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + return false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Close the file + return true; // Indicate success + +failure: + fclose(fh); + return false; // Propagate the error +} + +// If the functions indicate errors using exceptions, +// things are a little cleaner, but still sub-optimal. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Open the file in read mode + if (fh == nullptr) + throw std::runtime_error("Could not open the file."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Be sure to close the file if an error occurs. + throw; // Then re-throw the exception. + } + + fclose(fh); // Close the file + // Everything succeeded +} + +// Compare this to the use of C++'s file stream class (fstream) +// fstream uses its destructor to close the file. +// Recall from above that destructors are automatically called +// whenever an object falls out of scope. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream is short for input file stream + std::ifstream fh(filename); // Open the file + + // Do things with the file + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // The file is automatically closed here by the destructor + +// This has _massive_ advantages: +// 1. No matter what happens, +// the resource (in this case the file handle) will be cleaned up. +// Once you write the destructor correctly, +// It is _impossible_ to forget to close the handle and leak the resource. +// 2. Note that the code is much cleaner. +// The destructor handles closing the file behind the scenes +// without you having to worry about it. +// 3. The code is exception safe. +// An exception can be thrown anywhere in the function and cleanup +// will still occur. + +// All idiomatic C++ code uses RAII extensively for all resources. +// Additional examples include +// - Memory using unique_ptr and shared_ptr +// - Containers - the standard library linked list, +// vector (i.e. self-resizing array), hash maps, and so on +// all automatically destroy their contents when they fall out of scope. +// - Mutexes using lock_guard and unique_lock + + +///////////////////// +// Fun stuff +///////////////////// + +// Aspects of C++ that may be surprising to newcomers (and even some veterans). +// This section is, unfortunately, wildly incomplete; C++ is one of the easiest +// languages with which to shoot yourself in the foot. + +// You can override private methods! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // Overrides Foo::bar! +}; + + +// 0 == false == NULL (most of the time)! +bool* pt = new bool; +*pt = 0; // Sets the value points by 'pt' to false. +pt = 0; // Sets 'pt' to the null pointer. Both lines compile without warnings. + +// nullptr is supposed to fix some of that issue: +int* pt2 = new int; +*pt2 = nullptr; // Doesn't compile +pt2 = nullptr; // Sets pt2 to null. + +// There is an exception made for bools. +// This is to allow you to test for null pointers with if(!ptr), +// but as a consequence you can assign nullptr to a bool directly! +*pt = nullptr; // This still compiles, even though '*pt' is a bool! + + +// '=' != '=' != '='! +// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy +// constructor. +Foo f2; +Foo f1 = f2; + +// Calls Foo::Foo(const Foo&) or variant, but only copies the 'Foo' part of +// 'fooSub'. Any extra members of 'fooSub' are discarded. This sometimes +// horrifying behavior is called "object slicing." +FooSub fooSub; +Foo f1 = fooSub; + +// Calls Foo::operator=(Foo&) or variant. +Foo f1; +f1 = f2; + + +// How to truly clear a container: +class Foo { ... }; +vector<Foo> v; +for (int i = 0; i < 10; ++i) + v.push_back(Foo()); + +// Following line sets size of v to 0, but destructors don't get called +// and resources aren't released! +v.empty(); +v.push_back(Foo()); // New value is copied into the first Foo we inserted + +// Truly destroys all values in v. See section about temporary objects for +// explanation of why this works. +v.swap(vector<Foo>()); + +``` +Further Reading: + +An up-to-date language reference can be found at +<http://cppreference.com/w/cpp> + +Additional resources may be found at <http://cplusplus.com> diff --git a/c.html.markdown b/c.html.markdown index 132f75dc..db2ac930 100644 --- a/c.html.markdown +++ b/c.html.markdown @@ -3,289 +3,432 @@ language: c filename: learnc.c contributors: - ["Adam Bard", "http://adambard.com/"] + - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] + - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"] + - ["Marco Scannadinari", "https://marcoms.github.io"] + --- -Ah, C. Still the language of modern high-performance computing. +Ah, C. Still **the** language of modern high-performance computing. C is the lowest-level language most programmers will ever use, but it more than makes up for it with raw speed. Just be aware of its manual memory management and C will take you as far as you need to go. ```c -// Single-line comments start with // +// Single-line comments start with // - only available in C99 and later. /* -Multi-line comments look like this. +Multi-line comments look like this. They work in C89 as well. */ +/* +Multi-line comments don't nest /* Be careful */ // comment ends on this line... +*/ // ...not this one! + +// Constants: #define <keyword> +#define DAYS_IN_YEAR 365 + +// Enumeration constants are also ways to declare constants. +// All statements must end with a semicolon +enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT}; +// MON gets 2 automatically, TUE gets 3, etc. + + // Import headers with #include #include <stdlib.h> #include <stdio.h> #include <string.h> +// (File names between <angle brackets> are headers from the C standard library.) +// For your own headers, use double quotes instead of angle brackets: +//#include "my_header.h" + // Declare function signatures in advance in a .h file, or at the top of // your .c file. void function_1(); -void function_2(); +int function_2(void); + +// Must declare a 'function prototype' before main() when functions occur after +// your main() function. +int add_two_ints(int x1, int x2); // function prototype // Your program's entry point is a function called // main with an integer return type. -int main() { - -// print output using printf, for "print formatted" -// %d is an integer, \n is a newline -printf("%d\n", 0); // => Prints 0 -// All statements must end with a semicolon - -/////////////////////////////////////// -// Types -/////////////////////////////////////// - -// You have to declare variables before using them. A variable declaration -// requires you to specify its type; a variable's type determines its size -// in bytes. - -// ints are usually 4 bytes -int x_int = 0; - -// shorts are usually 2 bytes -short x_short = 0; - -// chars are guaranteed to be 1 byte -char x_char = 0; -char y_char = 'y'; // Char literals are quoted with '' - -// longs are often 4 to 8 bytes; long longs are guaranteed to be at least -// 64 bits -long x_long = 0; -long long x_long_long = 0; - -// floats are usually 32-bit floating point numbers -float x_float = 0.0; - -// doubles are usually 64-bit floating-point numbers -double x_double = 0.0; - -// Integral types may be unsigned. This means they can't be negative, but -// the maximum value of an unsigned variable is greater than the maximum -// value of the same size. -unsigned char ux_char; -unsigned short ux_short; -unsigned int ux_int; -unsigned long long ux_long_long; - -// Other than char, which is always 1 byte, these types vary in size depending -// on your machine. sizeof(T) gives you the size of a variable with type T in -// bytes so you can express the size of these types in a portable way. -// For example, -printf("%lu\n", sizeof(int)); // => 4 (on machines with 4-byte words) - -// Arrays must be initialized with a concrete size. -char my_char_array[20]; // This array occupies 1 * 20 = 20 bytes -int my_int_array[20]; // This array occupies 4 * 20 = 80 bytes - // (assuming 4-byte words) - - -// You can initialize an array to 0 thusly: -char my_array[20] = {0}; - -// Indexing an array is like other languages -- or, -// rather, other languages are like C -my_array[0]; // => 0 - -// Arrays are mutable; it's just memory! -my_array[1] = 2; -printf("%d\n", my_array[1]); // => 2 - -// Strings are just arrays of chars terminated by a NUL (0x00) byte, -// represented in strings as the special character '\0'. -// (We don't have to include the NUL byte in string literals; the compiler -// inserts it at the end of the array for us.) -char a_string[20] = "This is a string"; -printf("%s\n", a_string); // %s formats a string - -/* -You may have noticed that a_string is only 16 chars long. -Char #17 is the NUL byte. -Chars #18, 19 and 20 have undefined values. -*/ - -printf("%d\n", a_string[16]); // => 0 - -/////////////////////////////////////// -// Operators -/////////////////////////////////////// - -int i1 = 1, i2 = 2; // Shorthand for multiple declaration -float f1 = 1.0, f2 = 2.0; - -// Arithmetic is straightforward -i1 + i2; // => 3 -i2 - i1; // => 1 -i2 * i1; // => 2 -i1 / i2; // => 0 (0.5, but truncated towards 0) - -f1 / f2; // => 0.5, plus or minus epsilon - -// Modulo is there as well -11 % 3; // => 2 - -// Comparison operators are probably familiar, but -// there is no boolean type in c. We use ints instead. -// 0 is false, anything else is true. (The comparison -// operators always return 0 or 1.) -3 == 2; // => 0 (false) -3 != 2; // => 1 (true) -3 > 2; // => 1 -3 < 2; // => 0 -2 <= 2; // => 1 -2 >= 2; // => 1 - -// Logic works on ints -!3; // => 0 (Logical not) -!0; // => 1 -1 && 1; // => 1 (Logical and) -0 && 1; // => 0 -0 || 1; // => 1 (Logical or) -0 || 0; // => 0 - -// Bitwise operators! -~0x0F; // => 0xF0 (bitwise negation) -0x0F & 0xF0; // => 0x00 (bitwise AND) -0x0F | 0xF0; // => 0xFF (bitwise OR) -0x04 ^ 0x0F; // => 0x0B (bitwise XOR) -0x01 << 1; // => 0x02 (bitwise left shift (by 1)) -0x02 >> 1; // => 0x01 (bitwise right shift (by 1)) - -/////////////////////////////////////// -// Control Structures -/////////////////////////////////////// - -if (0) { - printf("I am never run\n"); -} else if (0) { - printf("I am also never run\n"); -} else { - printf("I print\n"); -} - -// While loops exist -int ii = 0; -while (ii < 10) { - printf("%d, ", ii++); // ii++ increments ii in-place, after using its value. -} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " - -printf("\n"); - -int kk = 0; -do { +int main(void) { + // print output using printf, for "print formatted" + // %d is an integer, \n is a newline + printf("%d\n", 0); // => Prints 0 + + /////////////////////////////////////// + // Types + /////////////////////////////////////// + + // ints are usually 4 bytes + int x_int = 0; + + // shorts are usually 2 bytes + short x_short = 0; + + // chars are guaranteed to be 1 byte + char x_char = 0; + char y_char = 'y'; // Char literals are quoted with '' + + // longs are often 4 to 8 bytes; long longs are guaranteed to be at least + // 64 bits + long x_long = 0; + long long x_long_long = 0; + + // floats are usually 32-bit floating point numbers + float x_float = 0.0f; // 'f' suffix here denotes floating point literal + + // doubles are usually 64-bit floating-point numbers + double x_double = 0.0; // real numbers without any suffix are doubles + + // integer types may be unsigned (greater than or equal to zero) + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // chars inside single quotes are integers in machine's character set. + '0'; // => 48 in the ASCII character set. + 'A'; // => 65 in the ASCII character set. + + // sizeof(T) gives you the size of a variable with type T in bytes + // sizeof(obj) yields the size of the expression (variable, literal, etc.). + printf("%zu\n", sizeof(int)); // => 4 (on most machines with 4-byte words) + + + // If the argument of the `sizeof` operator is an expression, then its argument + // is not evaluated (except VLAs (see below)). + // The value it yields in this case is a compile-time constant. + int a = 1; + // size_t is an unsigned integer type of at least 2 bytes used to represent + // the size of an object. + size_t size = sizeof(a++); // a++ is not evaluated + printf("sizeof(a++) = %zu where a = %d\n", size, a); + // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture) + + // Arrays must be initialized with a concrete size. + char my_char_array[20]; // This array occupies 1 * 20 = 20 bytes + int my_int_array[20]; // This array occupies 4 * 20 = 80 bytes + // (assuming 4-byte words) + + + // You can initialize an array to 0 thusly: + char my_array[20] = {0}; + + // Indexing an array is like other languages -- or, + // rather, other languages are like C + my_array[0]; // => 0 + + // Arrays are mutable; it's just memory! + my_array[1] = 2; + printf("%d\n", my_array[1]); // => 2 + + // In C99 (and as an optional feature in C11), variable-length arrays (VLAs) + // can be declared as well. The size of such an array need not be a compile + // time constant: + printf("Enter the array size: "); // ask the user for an array size + int size; + fscanf(stdin, "%d", &size); + char buf[size]; + fgets(buf, sizeof buf, stdin); + + // strtoul parses a string to an unsigned integer + size_t size2 = strtoul(buf, NULL, 10); + int var_length_array[size2]; // declare the VLA + printf("sizeof array = %zu\n", sizeof var_length_array); + + // A possible outcome of this program may be: + // > Enter the array size: 10 + // > sizeof array = 40 + + // Strings are just arrays of chars terminated by a NULL (0x00) byte, + // represented in strings as the special character '\0'. + // (We don't have to include the NULL byte in string literals; the compiler + // inserts it at the end of the array for us.) + char a_string[20] = "This is a string"; + printf("%s\n", a_string); // %s formats a string + + printf("%d\n", a_string[16]); // => 0 + // i.e., byte #17 is 0 (as are 18, 19, and 20) + + // If we have characters between single quotes, that's a character literal. + // It's of type `int`, and *not* `char` (for historical reasons). + int cha = 'a'; // fine + char chb = 'a'; // fine too (implicit conversion from int to char) + + // Multi-dimensional arrays: + int multi_array[2][5] = { + {1, 2, 3, 4, 5}, + {6, 7, 8, 9, 0} + }; + // access elements: + int array_int = multi_array[0][2]; // => 3 + + /////////////////////////////////////// + // Operators + /////////////////////////////////////// + + // Shorthands for multiple declarations: + int i1 = 1, i2 = 2; + float f1 = 1.0, f2 = 2.0; + + int b, c; + b = c = 0; + + // Arithmetic is straightforward + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5, but truncated towards 0) + + // You need to cast at least one integer to float to get a floating-point result + (float)i1 / i2; // => 0.5f + i1 / (double)i2; // => 0.5 // Same with double + f1 / f2; // => 0.5, plus or minus epsilon + // Floating-point numbers and calculations are not exact + + // Modulo is there as well + 11 % 3; // => 2 + + // Comparison operators are probably familiar, but + // there is no Boolean type in c. We use ints instead. + // (Or _Bool or bool in C99.) + // 0 is false, anything else is true. (The comparison + // operators always yield 0 or 1.) + 3 == 2; // => 0 (false) + 3 != 2; // => 1 (true) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C is not Python - comparisons don't chain. + // Warning: The line below will compile, but it means `(0 < a) < 2`. + // This expression is always true, because (0 < a) could be either 1 or 0. + // In this case it's 1, because (0 < 1). + int between_0_and_2 = 0 < a < 2; + // Instead use: + int between_0_and_2 = 0 < a && a < 2; + + // Logic works on ints + !3; // => 0 (Logical not) + !0; // => 1 + 1 && 1; // => 1 (Logical and) + 0 && 1; // => 0 + 0 || 1; // => 1 (Logical or) + 0 || 0; // => 0 + + // Conditional expression ( ? : ) + int e = 5; + int f = 10; + int z; + z = (e > f) ? e : f; // => 10 "if e > f return e, else return f." + + // Increment and decrement operators: + char *s = "iLoveC"; + int j = 0; + s[j++]; // => "i". Returns the j-th item of s THEN increments value of j. + j = 0; + s[++j]; // => "L". Increments value of j THEN returns j-th value of s. + // same with j-- and --j + + // Bitwise operators! + ~0x0F; // => 0xFFFFFFF0 (bitwise negation, "1's complement", example result for 32-bit int) + 0x0F & 0xF0; // => 0x00 (bitwise AND) + 0x0F | 0xF0; // => 0xFF (bitwise OR) + 0x04 ^ 0x0F; // => 0x0B (bitwise XOR) + 0x01 << 1; // => 0x02 (bitwise left shift (by 1)) + 0x02 >> 1; // => 0x01 (bitwise right shift (by 1)) + + // Be careful when shifting signed integers - the following are undefined: + // - shifting into the sign bit of a signed integer (int a = 1 << 31) + // - left-shifting a negative number (int a = -1 << 2) + // - shifting by an offset which is >= the width of the type of the LHS: + // int a = 1 << 32; // UB if int is 32 bits wide + + /////////////////////////////////////// + // Control Structures + /////////////////////////////////////// + + if (0) { + printf("I am never run\n"); + } else if (0) { + printf("I am also never run\n"); + } else { + printf("I print\n"); + } + + // While loops exist + int ii = 0; + while (ii < 10) { //ANY value not zero is true. + printf("%d, ", ii++); // ii++ increments ii AFTER using its current value. + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + int kk = 0; + do { printf("%d, ", kk); -} while (++kk < 10); // ++kk increments kk in-place, before using its value -// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + } while (++kk < 10); // ++kk increments kk BEFORE using its current value. + // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " -printf("\n"); + printf("\n"); -// For loops too -int jj; -for (jj=0; jj < 10; jj++) { + // For loops too + int jj; + for (jj=0; jj < 10; jj++) { printf("%d, ", jj); -} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " - -printf("\n"); - -/////////////////////////////////////// -// Typecasting -/////////////////////////////////////// - -// Every value in C has a type, but you can cast one value into another type -// if you want. - -int x_hex = 0x01; // You can assign vars with hex literals - -// Casting between types will attempt to preserve their numeric values -printf("%d\n", x_hex); // => Prints 1 -printf("%d\n", (short) x_hex); // => Prints 1 -printf("%d\n", (char) x_hex); // => Prints 1 - -// Types will overflow without warning -printf("%d\n", (char) 257); // => 1 (Max char = 255) - -// Integral types can be cast to floating-point types, and vice-versa. -printf("%f\n", (float)100); // %f formats a float -printf("%lf\n", (double)100); // %lf formats a double -printf("%d\n", (char)100.0); - -/////////////////////////////////////// -// Pointers -/////////////////////////////////////// - -// A pointer is a variable declared to store a memory address. Its declaration will -// also tell you the type of data it points to. You can retrieve the memory address -// of your variables, then mess with them. - -int x = 0; -printf("%p\n", &x); // Use & to retrieve the address of a variable -// (%p formats a pointer) -// => Prints some address in memory; - -// Pointer types end with * in their declaration -int* px; // px is a pointer to an int -px = &x; // Stores the address of x in px -printf("%p\n", px); // => Prints some address in memory - -// To retreive the value at the address a pointer is pointing to, -// put * in front to de-reference it. -printf("%d\n", *px); // => Prints 0, the value of x, which is what px is pointing to the address of - -// You can also change the value the pointer is pointing to. -// We'll have to wrap the de-reference in parenthesis because -// ++ has a higher precedence than *. -(*px)++; // Increment the value px is pointing to by 1 -printf("%d\n", *px); // => Prints 1 -printf("%d\n", x); // => Prints 1 - -int x_array[20]; // Arrays are a good way to allocate a contiguous block of memory -int xx; -for (xx=0; xx<20; xx++) { + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // *****NOTES*****: + // Loops and Functions MUST have a body. If no body is needed: + int i; + for (i = 0; i <= 5; i++) { + ; // use semicolon to act as the body (null statement) + } + + // branching with multiple choices: switch() + switch (a) { + case 0: // labels need to be integral *constant* expressions + printf("Hey, 'a' equals 0!\n"); + break; // if you don't break, control flow falls over labels + case 1: + printf("Huh, 'a' equals 1!\n"); + break; + default: + // if `some_integral_expression` didn't match any of the labels + fputs("error!\n", stderr); + exit(-1); + break; + } + + /////////////////////////////////////// + // Typecasting + /////////////////////////////////////// + + // Every value in C has a type, but you can cast one value into another type + // if you want (with some constraints). + + int x_hex = 0x01; // You can assign vars with hex literals + + // Casting between types will attempt to preserve their numeric values + printf("%d\n", x_hex); // => Prints 1 + printf("%d\n", (short) x_hex); // => Prints 1 + printf("%d\n", (char) x_hex); // => Prints 1 + + // Types will overflow without warning + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 if char is 8 bits long) + + // For determining the max value of a `char`, a `signed char` and an `unsigned char`, + // respectively, use the CHAR_MAX, SCHAR_MAX and UCHAR_MAX macros from <limits.h> + + // Integral types can be cast to floating-point types, and vice-versa. + printf("%f\n", (float)100); // %f formats a float + printf("%lf\n", (double)100); // %lf formats a double + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // Pointers + /////////////////////////////////////// + + // A pointer is a variable declared to store a memory address. Its declaration will + // also tell you the type of data it points to. You can retrieve the memory address + // of your variables, then mess with them. + + int x = 0; + printf("%p\n", (void *)&x); // Use & to retrieve the address of a variable + // (%p formats an object pointer of type void *) + // => Prints some address in memory; + + + // Pointers start with * in their declaration + int *px, not_a_pointer; // px is a pointer to an int + px = &x; // Stores the address of x in px + printf("%p\n", (void *)px); // => Prints some address in memory + printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer)); + // => Prints "8, 4" on a typical 64-bit system + + // To retrieve the value at the address a pointer is pointing to, + // put * in front to dereference it. + // Note: yes, it may be confusing that '*' is used for _both_ declaring a + // pointer and dereferencing it. + printf("%d\n", *px); // => Prints 0, the value of x + + // You can also change the value the pointer is pointing to. + // We'll have to wrap the dereference in parenthesis because + // ++ has a higher precedence than *. + (*px)++; // Increment the value px is pointing to by 1 + printf("%d\n", *px); // => Prints 1 + printf("%d\n", x); // => Prints 1 + + // Arrays are a good way to allocate a contiguous block of memory + int x_array[20]; //declares array of size 20 (cannot change size) + int xx; + for (xx = 0; xx < 20; xx++) { x_array[xx] = 20 - xx; -} // Initialize x_array to 20, 19, 18,... 2, 1 - -// Declare a pointer of type int and initialize it to point to x_array -int* x_ptr = x_array; -// x_ptr now points to the first element in the array (the integer 20). -// This works because arrays are actually just pointers to their first element. - -// Arrays are pointers to their first element -printf("%d\n", *(x_ptr)); // => Prints 20 -printf("%d\n", x_array[0]); // => Prints 20 - -// Pointers are incremented and decremented based on their type -printf("%d\n", *(x_ptr + 1)); // => Prints 19 -printf("%d\n", x_array[1]); // => Prints 19 - -// You can also dynamically allocate contiguous blocks of memory with the -// standard library function malloc, which takes one integer argument -// representing the number of bytes to allocate from the heap. -int* my_ptr = (int*) malloc(sizeof(int) * 20); -for (xx=0; xx<20; xx++) { - *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx would also work here -} // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints) - -// Dereferencing memory that you haven't allocated gives -// unpredictable results -printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what? - -// When you're done with a malloc'd block of memory, you need to free it, -// or else no one else can use it until your program terminates -free(my_ptr); - -// Strings can be char arrays, but are usually represented as char -// pointers: -char* my_str = "This is my very own string"; - -printf("%c\n", *my_str); // => 'T' - -function_1(); + } // Initialize x_array to 20, 19, 18,... 2, 1 + + // Declare a pointer of type int and initialize it to point to x_array + int* x_ptr = x_array; + // x_ptr now points to the first element in the array (the integer 20). + // This works because arrays often decay into pointers to their first element. + // For example, when an array is passed to a function or is assigned to a pointer, + // it decays into (implicitly converted to) a pointer. + // Exceptions: when the array is the argument of the `&` (address-of) operator: + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`! + // It's of type "pointer to array" (of ten `int`s). + // or when the array is a string literal used for initializing a char array: + char otherarr[] = "foobarbazquirk"; + // or when it's the argument of the `sizeof` or `alignof` operator: + int arraythethird[10]; + int *ptr = arraythethird; // equivalent with int *ptr = &arr[0]; + printf("%zu, %zu\n", sizeof arraythethird, sizeof ptr); + // probably prints "40, 4" or "40, 8" + + + // Pointers are incremented and decremented based on their type + // (this is called pointer arithmetic) + printf("%d\n", *(x_ptr + 1)); // => Prints 19 + printf("%d\n", x_array[1]); // => Prints 19 + + // You can also dynamically allocate contiguous blocks of memory with the + // standard library function malloc, which takes one argument of type size_t + // representing the number of bytes to allocate (usually from the heap, although this + // may not be true on e.g. embedded systems - the C standard says nothing about it). + int *my_ptr = malloc(sizeof(*my_ptr) * 20); + for (xx = 0; xx < 20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx + } // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints) + + // Dereferencing memory that you haven't allocated gives + // "unpredictable results" - the program is said to invoke "undefined behavior" + printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what? It may even crash. + + // When you're done with a malloc'd block of memory, you need to free it, + // or else no one else can use it until your program terminates + // (this is called a "memory leak"): + free(my_ptr); + + // Strings are arrays of char, but they are usually represented as a + // pointer-to-char (which is a pointer to the first element of the array). + // It's good practice to use `const char *' when referring to a string literal, + // since string literals shall not be modified (i.e. "foo"[0] = 'a' is ILLEGAL.) + const char *my_str = "This is my very own string literal"; + printf("%c\n", *my_str); // => 'T' + + // This is not the case if the string is an array + // (potentially initialized with a string literal) + // that resides in writable memory, as in: + char foo[] = "foo"; + foo[0] = 'a'; // this is legal, foo now contains "aoo" + + function_1(); } // end main function /////////////////////////////////////// @@ -295,26 +438,33 @@ function_1(); // Function declaration syntax: // <return type> <function name>(<args>) -int add_two_ints(int x1, int x2){ - return x1 + x2; // Use return to return a value +int add_two_ints(int x1, int x2) +{ + return x1 + x2; // Use return to return a value } /* -Functions are pass-by-value, but you can make your own references -with pointers so functions can mutate their values. +Functions are call by value. When a function is called, the arguments passed to +≈the function are copies of the original arguments (except arrays). Anything you +do to the arguments in the function do not change the value of the original +argument where the function was called. + +Use pointers if you need to edit the original argument values. Example: in-place string reversal */ // A void function returns no value -void str_reverse(char* str_in){ - char tmp; - int ii=0, len = strlen(str_in); // Strlen is part of the c standard library - for(ii=0; ii<len/2; ii++){ - tmp = str_in[ii]; - str_in[ii] = str_in[len - ii - 1]; // ii-th char from end - str_in[len - ii - 1] = tmp; - } +void str_reverse(char *str_in) +{ + char tmp; + int ii = 0; + size_t len = strlen(str_in); // `strlen()` is part of the c standard library + for (ii = 0; ii < len / 2; ii++) { + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // ii-th char from end + str_in[len - ii - 1] = tmp; + } } /* @@ -323,6 +473,21 @@ str_reverse(c); printf("%s\n", c); // => ".tset a si sihT" */ +// if referring to external variables outside function, must use extern keyword. +int i = 0; +void testFunc() { + extern int i; //i here is now using external variable i +} + +// make external variables private to source file with static: +static int j = 0; //other files using testFunc2() cannot access variable j +void testFunc2() { + extern int j; +} +//**You may also declare functions as static to make them private** + + + /////////////////////////////////////// // User-defined types and structs /////////////////////////////////////// @@ -331,55 +496,69 @@ printf("%s\n", c); // => ".tset a si sihT" typedef int my_type; my_type my_type_var = 0; -// Structs are just collections of data +// Structs are just collections of data, the members are allocated sequentially, +// in the order they are written: struct rectangle { - int width; - int height; + int width; + int height; }; +// It's not generally true that +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) +// due to potential padding between the structure members (this is for alignment +// reasons). [1] -void function_1(){ +void function_1() +{ + struct rectangle my_rec; - struct rectangle my_rec; + // Access struct members with . + my_rec.width = 10; + my_rec.height = 20; - // Access struct members with . - my_rec.width = 10; - my_rec.height = 20; + // You can declare pointers to structs + struct rectangle *my_rec_ptr = &my_rec; - // You can declare pointers to structs - struct rectangle* my_rec_ptr = &my_rec; + // Use dereferencing to set struct pointer members... + (*my_rec_ptr).width = 30; - // Use dereferencing to set struct pointer members... - (*my_rec_ptr).width = 30; - - // ... or use the -> shorthand - my_rec_ptr->height = 10; // Same as (*my_rec_ptr).height = 10; + // ... or even better: prefer the -> shorthand for the sake of readability + my_rec_ptr->height = 10; // Same as (*my_rec_ptr).height = 10; } // You can apply a typedef to a struct for convenience typedef struct rectangle rect; -int area(rect r){ - return r.width * r.height; +int area(rect r) +{ + return r.width * r.height; +} + +// if you have large structs, you can pass them "by pointer" to avoid copying +// the whole struct: +int areaptr(const rect *r) +{ + return r->width * r->height; } /////////////////////////////////////// -// Function pointers +// Function pointers /////////////////////////////////////// /* -At runtime, functions are located at known memory addresses. Function pointers are -much likely any other pointer (they just store a memory address), but can be used +At run time, functions are located at known memory addresses. Function pointers are +much like any other pointer (they just store a memory address), but can be used to invoke functions directly, and to pass handlers (or callback functions) around. However, definition syntax may be initially confusing. Example: use str_reverse from a pointer */ -void str_reverse_through_pointer(char * str_in) { - // Define a function pointer variable, named f. - void (*f)(char *); // Signature should exactly match the target function. - f = &str_reverse; // Assign the address for the actual function (determined at runtime) - (*f)(str_in); // Just calling the function through the pointer - // f(str_in); // That's an alternative but equally valid syntax for calling it. +void str_reverse_through_pointer(char *str_in) { + // Define a function pointer variable, named f. + void (*f)(char *); // Signature should exactly match the target function. + f = &str_reverse; // Assign the address for the actual function (determined at run time) + // f = str_reverse; would work as well - functions decay into pointers, similar to arrays + (*f)(str_in); // Just calling the function through the pointer + // f(str_in); // That's an alternative but equally valid syntax for calling it. } /* @@ -389,16 +568,82 @@ Function pointers are usually typedef'd for simplicity and readability, as follo typedef void (*my_fnp_type)(char *); -// The used when declaring the actual pointer variable: +// Then used when declaring the actual pointer variable: // ... -// my_fnp_type f; +// my_fnp_type f; + +//Special characters: +/* +'\a'; // alert (bell) character +'\n'; // newline character +'\t'; // tab character (left justifies text) +'\v'; // vertical tab +'\f'; // new page (form feed) +'\r'; // carriage return +'\b'; // backspace character +'\0'; // NULL character. Usually put at end of strings in C. +// hello\n\0. \0 used by convention to mark end of string. +'\\'; // backslash +'\?'; // question mark +'\''; // single quote +'\"'; // double quote +'\xhh'; // hexadecimal number. Example: '\xb' = vertical tab character +'\0oo'; // octal number. Example: '\013' = vertical tab character + +//print formatting: +"%d"; // integer +"%3d"; // integer with minimum of length 3 digits (right justifies text) +"%s"; // string +"%f"; // float +"%ld"; // long +"%3.2f"; // minimum 3 digits left and 2 digits right decimal float +"%7.4s"; // (can do with strings too) +"%c"; // char +"%p"; // pointer +"%x"; // hexadecimal +"%o"; // octal +"%%"; // prints % +*/ +/////////////////////////////////////// +// Order of Evaluation +/////////////////////////////////////// + +//---------------------------------------------------// +// Operators | Associativity // +//---------------------------------------------------// +// () [] -> . | left to right // +// ! ~ ++ -- + = *(type)sizeof | right to left // +// * / % | left to right // +// + - | left to right // +// << >> | left to right // +// < <= > >= | left to right // +// == != | left to right // +// & | left to right // +// ^ | left to right // +// | | left to right // +// && | left to right // +// || | left to right // +// ?: | right to left // +// = += -= *= /= %= &= ^= |= <<= >>= | right to left // +// , | left to right // +//---------------------------------------------------// ``` ## Further Reading Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language) +It is *the* book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some +inaccuracies (well, ideas that are not considered good anymore) or now-changed practices. + +Another good resource is [Learn C The Hard Way](http://c.learncodethehardway.org/book/). -Another good resource is [Learn C the hard way](http://c.learncodethehardway.org/book/) +If you have a question, read the [compl.lang.c Frequently Asked Questions](http://c-faq.com). + +It's very important to use proper spacing, indentation and to be consistent with your coding style in general. +Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the +[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle). Other than that, Google is your friend. + +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member diff --git a/chapel.html.markdown b/chapel.html.markdown new file mode 100644 index 00000000..e20be998 --- /dev/null +++ b/chapel.html.markdown @@ -0,0 +1,1103 @@ +--- +language: chapel +filename: learnchapel.chpl +contributors: + - ["Ian J. Bertolacci", "http://www.cs.colostate.edu/~ibertola/"] +--- + +You can read all about Chapel at [Cray's official Chapel website](http://chapel.cray.com). +In short, Chapel is an open-source, high-productivity, parallel-programming language in development at Cray Inc., and is designed to run on multi-core PCs as well as multi-kilocore supercomputers. + +More information and support can be found at the bottom of this document. + +```c +// Comments are C-family style +// one line comment +/* + multi-line comment +*/ + +// Basic printing +write( "Hello, " ); +writeln( "World!" ); +// write and writeln can take a list of things to print. +// each thing is printed right next to each other, so include your spacing! +writeln( "There are ", 3, " commas (\",\") in this line of code" ); +// Different output channels +stdout.writeln( "This goes to standard output, just like plain writeln() does"); +stderr.writeln( "This goes to standard error" ); + +// Variables don't have to be explicitly typed as long as +// the compiler can figure out the type that it will hold. +var myVar = 10; // 10 is an int, so myVar is implicitly an int +myVar = -10; +var mySecondVar = myVar; +// var anError; // this would be a compile-time error. + +// We can (and should) explicitly type things +var myThirdVar: real; +var myFourthVar: real = -1.234; +myThirdVar = myFourthVar; + +// There are a number of basic types. +var myInt: int = -1000; // Signed ints +var myUint: uint = 1234; // Unsigned ints +var myReal: real = 9.876; // Floating point numbers +var myImag: imag = 5.0i; // Imaginary numbers +var myCplx: complex = 10 + 9i; // Complex numbers +myCplx = myInt + myImag ; // Another way to form complex numbers +var myBool: bool = false; // Booleans +var myStr: string = "Some string..."; // Strings + +// Some types can have sizes +var my8Int: int(8) = 10; // 8 bit (one byte) sized int; +var my64Real: real(64) = 1.516; // 64 bit (8 bytes) sized real + +// Typecasting +var intFromReal = myReal : int; +var intFromReal2: int = myReal : int; + +// consts are constants, they cannot be changed after set in runtime. +const almostPi: real = 22.0/7.0; + +// params are constants whose value must be known statically at compile-time +// Their value cannot be changed. +param compileTimeConst: int = 16; + +// The config modifier allows values to be set at the command line +// and is much easier than the usual getOpts debacle +// config vars and consts can be changed through the command line at run time +config var varCmdLineArg: int = -123; +config const constCmdLineArg: int = 777; +// Set with --VarName=Value or --VarName Value at run time + +// config params can be set/changed at compile-time +config param paramCmdLineArg: bool = false; +// Set config with --set paramCmdLineArg=value at compile-time +writeln( varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg ); + +// refs operate much like a reference in C++ +var actual = 10; +ref refToActual = actual; // refToActual refers to actual +writeln( actual, " == ", refToActual ); // prints the same value +actual = -123; // modify actual (which refToActual refers to) +writeln( actual, " == ", refToActual ); // prints the same value +refToActual = 99999999; // modify what refToActual refers to (which is actual) +writeln( actual, " == ", refToActual ); // prints the same value + +// Math operators +var a: int, thisInt = 1234, thatInt = 5678; +a = thisInt + thatInt; // Addition +a = thisInt * thatInt; // Multiplication +a = thisInt - thatInt; // Subtraction +a = thisInt / thatInt; // Division +a = thisInt ** thatInt; // Exponentiation +a = thisInt % thatInt; // Remainder (modulo) + +// Logical Operators +var b: bool, thisBool = false, thatBool = true; +b = thisBool && thatBool; // Logical and +b = thisBool || thatBool; // Logical or +b = !thisBool; // Logical negation + +// Relational Operators +b = thisInt > thatInt; // Greater-than +b = thisInt >= thatInt; // Greater-than-or-equal-to +b = thisInt < a && a <= thatInt; // Less-than, and, less-than-or-equal-to +b = thisInt != thatInt; // Not-equal-to +b = thisInt == thatInt; // Equal-to + +// Bitwise operations +a = thisInt << 10; // Left-bit-shift by 10 bits; +a = thatInt >> 5; // Right-bit-shift by 5 bits; +a = ~thisInt; // Bitwise-negation +a = thisInt ^ thatInt; // Bitwise exclusive-or + +// Compound assignment operations +a += thisInt; // Addition-equals ( a = a + thisInt;) +a *= thatInt; // Times-equals ( a = a * thatInt; ) +b &&= thatBool; // Logical-and-equals ( b = b && thatBool; ) +a <<= 3; // Left-bit-shift-equals ( a = a << 10; ) +// and many, many more. +// Unlike other C family languages there are no +// pre/post-increment/decrement operators like +// ++j, --j, j++, j-- + +// Swap operator +var old_this = thisInt; +var old_that = thatInt; +thisInt <=> thatInt; // Swap the values of thisInt and thatInt +writeln( (old_this == thatInt) && (old_that == thisInt) ); + +// Operator overloads can also be defined, as we'll see with procedures + +// Tuples can be of the same type +var sameTup: 2*int = (10,-1); +var sameTup2 = (11, -6); +// or different types +var diffTup: (int,real,complex) = (5, 1.928, myCplx); +var diffTupe2 = ( 7, 5.64, 6.0+1.5i ); + +// Accessed using array bracket notation +// However, tuples are all 1-indexed +writeln( "(", sameTup[1], ",", sameTup[2], ")" ); +writeln( diffTup ); + +// Tuples can also be written into. +diffTup[1] = -1; + +// Can expand tuple values into their own variables +var (tupInt, tupReal, tupCplx) = diffTup; +writeln( diffTup == (tupInt, tupReal, tupCplx) ); + +// Useful for writing a list of variables ( as is common in debugging) +writeln( (a,b,thisInt,thatInt,thisBool,thatBool) ); + +// Type aliasing +type chroma = int; // Type of a single hue +type RGBColor = 3*chroma; // Type representing a full color +var black: RGBColor = ( 0,0,0 ); +var white: RGBColor = ( 255, 255, 255 ); + +// If-then-else works just like any other C-family language +if 10 < 100 then + writeln( "All is well" ); + +if -1 < 1 then + writeln( "Continuing to believe reality" ); +else + writeln( "Send mathematician, something's wrong" ); + +if ( 10 > 100 ) { + writeln( "Universe broken. Please reboot universe." ); +} + +if ( a % 2 == 0 ) { + writeln( a, " is even." ); +} else { + writeln( a, " is odd." ); +} + +if ( a % 3 == 0 ) { + writeln( a, " is even divisible by 3." ); +} else if ( a % 3 == 1 ){ + writeln( a, " is divided by 3 with a remainder of 1." ); +} else { + writeln( b, " is divided by 3 with a remainder of 2." ); +} + +// Ternary: if-then-else in a statement +var maximum = if ( thisInt < thatInt ) then thatInt else thisInt; + +// Select statements are much like switch statements in other languages +// However, Select statements don't cascade like in C or Java +var inputOption = "anOption"; +select( inputOption ){ + when "anOption" do writeln( "Chose 'anOption'" ); + when "otherOption" { + writeln( "Chose 'otherOption'" ); + writeln( "Which has a body" ); + } + otherwise { + writeln( "Any other Input" ); + writeln( "the otherwise case doesn't need a do if the body is one line" ); + } +} + +// While and Do-While loops are basically the same in every language. +var j: int = 1; +var jSum: int = 0; +while( j <= 1000 ){ + jSum += j; + j += 1; +} +writeln( jSum ); + +// Do-While loop +do{ + jSum += j; + j += 1; +}while( j <= 10000 ); +writeln( jSum ); + +// For loops are much like those in python in that they iterate over a range. +// Ranges themselves are types, and can be stuffed into variables +// (more about that later) +for i in 1..10 do write( i , ", ") ; +writeln( ); + +var iSum: int = 0; +for i in 1..1000 { + iSum += i; +} +writeln( iSum ); + +for x in 1..10 { + for y in 1..10 { + write( (x,y), "\t" ); + } + writeln( ); +} + +// Ranges and Domains +// For-loops and arrays both use ranges and domains to +// define an index set that can be iterated over. +// Ranges are single dimensional +// Domains can be multi-dimensional and can +// represent indices of different types as well. +// They are first-class citizen types, and can be assigned into variables +var range1to10: range = 1..10; // 1, 2, 3, ..., 10 +var range2to11 = 2..11; // 2, 3, 4, ..., 11 +var rangeThistoThat: range = thisInt..thatInt; // using variables +var rangeEmpty: range = 100..-100 ; // this is valid but contains no indices + +// Ranges can be unbounded +var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; +// 1, 2, 3, 4, 5, ... +// Note: the range(boundedType= ... ) is only +// necessary if we explicitly type the variable + +var rangeNegInfto1 = ..1; // ..., -4, -3, -2, -1, 0, 1 + +// Ranges can be strided using the 'by' operator. +var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10 +// Note: the range(stridable=true) is only +// necessary if we explicitly type the variable + +// Use by to create a reverse range +var reverse2to10by2 = 10..2 by -2; // 10, 8, 6, 4, 2 + +// The end point of a range can be determined using the count (#) operator +var rangeCount: range = -5..#12; // range from -5 to 6 + +// Can mix operators +var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5 +writeln( rangeCountBy ); + +// Can query properties of the range +// Print the first index, last index, number of indices, +// stride, and ask if 2 is include in the range +writeln( ( rangeCountBy.first, rangeCountBy.last, rangeCountBy.length, + rangeCountBy.stride, rangeCountBy.member( 2 ) ) ); + +for i in rangeCountBy{ + write( i, if i == rangeCountBy.last then "\n" else ", " ); +} + +// Rectangular domains are defined using the same range syntax +// However they are required to be bounded (unlike ranges) +var domain1to10: domain(1) = {1..10}; // 1D domain from 1..10; +var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges +var thirdDim: range = 1..16; +var threeDims: domain(3) = {thirdDim, 1..10, 5..10}; // using a range variable + +// Can iterate over the indices as tuples +for idx in twoDimensions do + write( idx , ", "); +writeln( ); + +// or can deconstruct the tuple +for (x,y) in twoDimensions { + write( "(", x, ", ", y, ")", ", " ); +} +writeln( ); + +// Associative domains act like sets +var stringSet: domain(string); // empty set of strings +stringSet += "a"; +stringSet += "b"; +stringSet += "c"; +stringSet += "a"; // Redundant add "a" +stringSet -= "c"; // Remove "c" +writeln( stringSet ); + +// Both ranges and domains can be sliced to produce a range or domain with the +// intersection of indices +var rangeA = 1.. ; // range from 1 to infinity +var rangeB = ..5; // range from negative infinity to 5 +var rangeC = rangeA[rangeB]; // resulting range is 1..5 +writeln( (rangeA, rangeB, rangeC ) ); + +var domainA = {1..10, 5..20}; +var domainB = {-5..5, 1..10}; +var domainC = domainA[domainB]; +writeln( (domainA, domainB, domainC) ); + +// Array are similar to those of other languages. +// Their sizes are defined using domains that represent their indices +var intArray: [1..10] int; +var intArray2: [{1..10}] int; //equivalent + +// Accessed using bracket notation +for i in 1..10 do + intArray[i] = -i; +writeln( intArray ); +// We cannot access intArray[0] because it exists outside +// of the index set, {1..10}, we defined it to have. +// intArray[11] is illegal for the same reason. + +var realDomain: domain(2) = {1..5,1..7}; +var realArray: [realDomain] real; +var realArray2: [1..5,1..7] real; // Equivalent +var realArray3: [{1..5,1..7}] real; // Equivalent + +for i in 1..5 { + for j in realDomain.dim(2) { // Only use the 2nd dimension of the domain + realArray[i,j] = -1.61803 * i + 0.5 * j; // Access using index list + var idx: 2*int = (i,j); // Note: 'index' is a keyword + realArray[idx] = - realArray[(i,j)]; // Index using tuples + } +} + +// Arrays have domains as members that we can iterate over +for idx in realArray.domain { // Again, idx is a 2*int tuple + realArray[idx] = 1 / realArray[idx[1],idx[2]]; // Access by tuple and list +} + +writeln( realArray ); + +// Can also iterate over the values of an array +var rSum: real = 0; +for value in realArray { + rSum += value; // Read a value + value = rSum; // Write a value +} +writeln( rSum, "\n", realArray ); + +// Using associative domains we can create associative arrays (dictionaries) +var dictDomain: domain(string) = { "one", "two" }; +var dict: [dictDomain] int = [ "one" => 1, "two" => 2 ]; +dict["three"] = 3; +for key in dictDomain do writeln( dict[key] ); + +// Arrays can be assigned to each other in different ways +var thisArray : [{0..5}] int = [0,1,2,3,4,5]; +var thatArray : [{0..5}] int; + +// Simply assign one to the other. +// This copies thisArray into thatArray, instead of just creating a reference. +// Modifying thisArray does not also modify thatArray. +thatArray = thisArray; +thatArray[1] = -1; +writeln( (thisArray, thatArray) ); + +// Assign a slice one array to a slice (of the same size) of the other. +thatArray[{4..5}] = thisArray[{1..2}]; +writeln( (thisArray, thatArray) ); + +// Operation can also be promoted to work on arrays. +var thisPlusThat = thisArray + thatArray; +writeln( thisPlusThat ); + +// Arrays and loops can also be expressions, where loop +// body's expression is the result of each iteration. +var arrayFromLoop = for i in 1..10 do i; +writeln( arrayFromLoop ); + +// An expression can result in nothing, +// such as when filtering with an if-expression +var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i; + +writeln( arrayFromLoop ); + +// Or could be written with a bracket notation +// Note: this syntax uses the 'forall' parallel concept discussed later. +var evensOrFivesAgain = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i; + +// Or over the values of the array +arrayFromLoop = [ value in arrayFromLoop ] value + 1; + +// Note: this notation can get somewhat tricky. For example: +// evensOrFives = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i; +// would break. +// The reasons for this are explained in depth when discussing zipped iterators. + +// Chapel procedures have similar syntax to other languages functions. +proc fibonacci( n : int ) : int { + if ( n <= 1 ) then return n; + return fibonacci( n-1 ) + fibonacci( n-2 ); +} + +// Input parameters can be untyped (a generic procedure) +proc doublePrint( thing ): void { + write( thing, " ", thing, "\n"); +} + +// Return type can be inferred (as long as the compiler can figure it out) +proc addThree( n ) { + return n + 3; +} + +doublePrint( addThree( fibonacci( 20 ) ) ); + +// Can also take 'unlimited' number of parameters +proc maxOf( x ...?k ) { + // x refers to a tuple of one type, with k elements + var maximum = x[1]; + for i in 2..k do maximum = if (maximum < x[i]) then x[i] else maximum; + return maximum; +} +writeln( maxOf( 1, -10, 189, -9071982, 5, 17, 20001, 42 ) ); + +// The ? operator is called the query operator, and is used to take +// undetermined values (like tuple or array sizes, and generic types). + +// Taking arrays as parameters. +// The query operator is used to determine the domain of A. +// This is important to define the return type (if you wanted to) +proc invertArray( A: [?D] int ): [D] int{ + for a in A do a = -a; + return A; +} + +writeln( invertArray( intArray ) ); + +// Procedures can have default parameter values, and +// the parameters can be named in the call, even out of order +proc defaultsProc( x: int, y: real = 1.2634 ): (int,real){ + return (x,y); +} + +writeln( defaultsProc( 10 ) ); +writeln( defaultsProc( x=11 ) ); +writeln( defaultsProc( x=12, y=5.432 ) ); +writeln( defaultsProc( y=9.876, x=13 ) ); + +// Intent modifiers on the arguments convey how +// those arguments are passed to the procedure +// in: copy arg in, but not out +// out: copy arg out, but not in +// inout: copy arg in, copy arg out +// ref: pass arg by reference +proc intentsProc( in inarg, out outarg, inout inoutarg, ref refarg ){ + writeln( "Inside Before: ", (inarg, outarg, inoutarg, refarg) ); + inarg = inarg + 100; + outarg = outarg + 100; + inoutarg = inoutarg + 100; + refarg = refarg + 100; + writeln( "Inside After: ", (inarg, outarg, inoutarg, refarg) ); +} + +var inVar: int = 1; +var outVar: int = 2; +var inoutVar: int = 3; +var refVar: int = 4; +writeln( "Outside Before: ", (inVar, outVar, inoutVar, refVar) ); +intentsProc( inVar, outVar, inoutVar, refVar ); +writeln( "Outside After: ", (inVar, outVar, inoutVar, refVar) ); + +// Similarly we can define intents on the return type +// refElement returns a reference to an element of array +proc refElement( array : [?D] ?T, idx ) ref : T { + return array[ idx ]; // returns a reference to +} + +var myChangingArray : [1..5] int = [1,2,3,4,5]; +writeln( myChangingArray ); +// Store reference to element in ref variable +ref refToElem = refElement( myChangingArray, 5 ); +writeln( refToElem ); +refToElem = -2; // modify reference which modifies actual value in array +writeln( refToElem ); +writeln( myChangingArray ); +// This makes more practical sense for class methods where references to +// elements in a data-structure are returned via a method or iterator + +// We can query the type of arguments to generic procedures +// Here we define a procedure that takes two arguments of +// the same type, yet we don't define what that type is. +proc genericProc( arg1 : ?valueType, arg2 : valueType ): void { + select( valueType ){ + when int do writeln( arg1, " and ", arg2, " are ints" ); + when real do writeln( arg1, " and ", arg2, " are reals" ); + otherwise writeln( arg1, " and ", arg2, " are somethings!" ); + } +} + +genericProc( 1, 2 ); +genericProc( 1.2, 2.3 ); +genericProc( 1.0+2.0i, 3.0+4.0i ); + +// We can also enforce a form of polymorphism with the 'where' clause +// This allows the compiler to decide which function to use. +// Note: that means that all information needs to be known at compile-time. +// The param modifier on the arg is used to enforce this constraint. +proc whereProc( param N : int ): void + where ( N > 0 ) { + writeln( "N is greater than 0" ); +} + +proc whereProc( param N : int ): void + where ( N < 0 ) { + writeln( "N is less than 0" ); +} + +whereProc( 10 ); +whereProc( -1 ); +// whereProc( 0 ) would result in a compiler error because there +// are no functions that satisfy the where clause's condition. +// We could have defined a whereProc without a where clause that would then have +// served as a catch all for all the other cases (of which there is only one). + +// Operator definitions are through procedures as well. +// We can define the unary operators: +// + - ! ~ +// and the binary operators: +// + - * / % ** == <= >= < > << >> & | ˆ by +// += -= *= /= %= **= &= |= ˆ= <<= >>= <=> + +// Boolean exclusive or operator +proc ^( left : bool, right : bool ): bool { + return (left || right) && !( left && right ); +} + +writeln( true ^ true ); +writeln( false ^ true ); +writeln( true ^ false ); +writeln( false ^ false ); + +// Define a * operator on any two types that returns a tuple of those types +proc *( left : ?ltype, right : ?rtype): ( ltype, rtype ){ + return (left, right ); +} + +writeln( 1 * "a" ); // Uses our * operator +writeln( 1 * 2 ); // Uses the default * operator + +/* +Note: You could break everything if you get careless with your overloads. +This here will break everything. Don't do it. +proc +( left: int, right: int ): int{ + return left - right; +} +*/ + +// Iterators are a sisters to the procedure, and almost +// everything about procedures also applies to iterators +// However, instead of returning a single value, +// iterators yield many values to a loop. +// This is useful when a complicated set or order of iterations is needed but +// allows the code defining the iterations to be separate from the loop body. +iter oddsThenEvens( N: int ): int { + for i in 1..N by 2 do + yield i; // yield values instead of returning. + for i in 2..N by 2 do + yield i; +} + +for i in oddsThenEvens( 10 ) do write( i, ", " ); +writeln( ); + +// Iterators can also yield conditionally, the result of which can be nothing +iter absolutelyNothing( N ): int { + for i in 1..N { + if ( N < i ) { // Always false + yield i; // Yield statement never happens + } + } +} + +for i in absolutelyNothing( 10 ){ + writeln( "Woa there! absolutelyNothing yielded ", i ); +} + +// We can zipper together two or more iterators (who have the same number +// of iterations) using zip() to create a single zipped iterator, where each +// iteration of the zipped iterator yields a tuple of one value yielded +// from each iterator. + // Ranges have implicit iterators +for (positive, negative) in zip( 1..5, -5..-1) do + writeln( (positive, negative) ); + +// Zipper iteration is quite important in the assignment of arrays, +// slices of arrays, and array/loop expressions. +var fromThatArray : [1..#5] int = [1,2,3,4,5]; +var toThisArray : [100..#5] int; + +// The operation +toThisArray = fromThatArray; +// is produced through +for (i,j) in zip( toThisArray.domain, fromThatArray.domain) { + toThisArray[ i ] = fromThatArray[ j ]; +} + +toThisArray = [ j in -100..#5 ] j; +writeln( toThisArray ); +// is produced through +for (i, j) in zip( toThisArray.domain, -100..#5 ){ + toThisArray[i] = j; +} +writeln( toThisArray ); + +// This is all very important in undestanding why the statement +// var iterArray : [1..10] int = [ i in 1..10 ] if ( i % 2 == 1 ) then j; +// exhibits a runtime error. +// Even though the domain of the array and the loop-expression are +// the same size, the body of the expression can be though of as an iterator. +// Because iterators can yield nothing, that iterator yields a different number +// of things than the domain of the array or loop, which is not allowed. + +// Classes are similar to those in C++ and Java. +// They currently lack privatization +class MyClass { + // Member variables + var memberInt : int; + var memberBool : bool = true; + + // Classes have default constructors that don't need to be coded (see below) + // Our explicitly defined constructor + proc MyClass( val : real ){ + this.memberInt = ceil( val ): int; + } + + // Our explicitly defined destructor + proc ~MyClass( ){ + writeln( "MyClass Destructor called ", (this.memberInt, this.memberBool) ); + } + + // Class methods + proc setMemberInt( val: int ){ + this.memberInt = val; + } + + proc setMemberBool( val: bool ){ + this.memberBool = val; + } + + proc getMemberInt( ): int{ + return this.memberInt; + } + + proc getMemberBool( ): bool { + return this.memberBool; + } + +} + +// Construct using default constructor, using default values +var myObject = new MyClass( 10 ); + myObject = new MyClass( memberInt = 10 ); // Equivalent +writeln( myObject.getMemberInt( ) ); +// ... using our values +var myDiffObject = new MyClass( -1, true ); + myDiffObject = new MyClass( memberInt = -1, + memberBool = true ); // Equivalent +writeln( myDiffObject ); + +// Construct using written constructor +var myOtherObject = new MyClass( 1.95 ); + myOtherObject = new MyClass( val = 1.95 ); // Equivalent +writeln( myOtherObject.getMemberInt( ) ); + +// We can define an operator on our class as well but +// the definition has to be outside the class definition +proc +( A : MyClass, B : MyClass) : MyClass { + return new MyClass( memberInt = A.getMemberInt( ) + B.getMemberInt( ), + memberBool = A.getMemberBool( ) || B.getMemberBool( ) ); +} + +var plusObject = myObject + myDiffObject; +writeln( plusObject ); + +// Destruction +delete myObject; +delete myDiffObject; +delete myOtherObject; +delete plusObject; + +// Classes can inherit from one or more parent classes +class MyChildClass : MyClass { + var memberComplex: complex; +} + +// Generic Classes +class GenericClass { + type classType; + var classDomain: domain(1); + var classArray: [classDomain] classType; + + // Explicit constructor + proc GenericClass( type classType, elements : int ){ + this.classDomain = {1..#elements}; + } + + // Copy constructor + // Note: We still have to put the type as an argument, but we can + // default to the type of the other object using the query (?) operator + // Further, we can take advantage of this to allow our copy constructor + // to copy classes of different types and cast on the fly + proc GenericClass( other : GenericClass(?otherType), + type classType = otherType ) { + this.classDomain = other.classDomain; + // Copy and cast + for idx in this.classDomain do this[ idx ] = other[ idx ] : classType; + } + + // Define bracket notation on a GenericClass + // object so it can behave like a normal array + // i.e. objVar[ i ] or objVar( i ) + proc this( i : int ) ref : classType { + return this.classArray[ i ]; + } + + // Define an implicit iterator for the class + // to yield values from the array to a loop + // i.e. for i in objVar do .... + iter these( ) ref : classType { + for i in this.classDomain do + yield this[i]; + } + +} + +var realList = new GenericClass( real, 10 ); +// We can assign to the member array of the object using the bracket +// notation that we defined ( proc this( i: int ){ ... } ) +for i in realList.classDomain do realList[i] = i + 1.0; +// We can iterate over the values in our list with the iterator +// we defined ( iter these( ){ ... } ) +for value in realList do write( value, ", " ); +writeln( ); + +// Make a copy of realList using the copy constructor +var copyList = new GenericClass( realList ); +for value in copyList do write( value, ", " ); +writeln( ); + +// Make a copy of realList and change the type, also using the copy constructor +var copyNewTypeList = new GenericClass( realList, int ); +for value in copyNewTypeList do write( value, ", " ); +writeln( ); + +// Modules are Chapel's way of managing name spaces. +// The files containing these modules do not need to be named after the modules +// (as in Java), but files implicitly name modules. +// In this case, this file implicitly names the 'learnchapel' module + +module OurModule { + // We can use modules inside of other modules. + use Time; // Time is one of the standard modules. + + // We'll use this procedure in the parallelism section. + proc countdown( seconds: int ){ + for i in 1..seconds by -1 { + writeln( i ); + sleep( 1 ); + } + } + + // Submodules of OurModule + // It is possible to create arbitrarily deep module nests. + module ChildModule { + proc foo(){ + writeln( "ChildModule.foo()"); + } + } + + module SiblingModule { + proc foo(){ + writeln( "SiblingModule.foo()" ); + } + } +} // end OurModule + +// Using OurModule also uses all the modules it uses. +// Since OurModule uses Time, we also use time. +use OurModule; + +// At this point we have not used ChildModule or SiblingModule so their symbols +// (i.e. foo ) are not available to us. +// However, the module names are, and we can explicitly call foo() through them. +SiblingModule.foo(); // Calls SiblingModule.foo() + +// Super explicit naming. +OurModule.ChildModule.foo(); // Calls ChildModule.foo() + +use ChildModule; +foo(); // Less explicit call on ChildModule.foo() + +// We can declare a main procedure +// Note: all the code above main still gets executed. +proc main(){ + + // Parallelism + // In other languages, parallelism is typically done with + // complicated libraries and strange class structure hierarchies. + // Chapel has it baked right into the language. + + // A begin statement will spin the body of that statement off + // into one new task. + // A sync statement will ensure that the progress of the main + // task will not progress until the children have synced back up. + sync { + begin { // Start of new task's body + var a = 0; + for i in 1..1000 do a += 1; + writeln( "Done: ", a); + } // End of new tasks body + writeln( "spun off a task!"); + } + writeln( "Back together" ); + + proc printFibb( n: int ){ + writeln( "fibonacci(",n,") = ", fibonacci( n ) ); + } + + // A cobegin statement will spin each statement of the body into one new task + cobegin { + printFibb( 20 ); // new task + printFibb( 10 ); // new task + printFibb( 5 ); // new task + { + // This is a nested statement body and thus is a single statement + // to the parent statement and is executed by a single task + writeln( "this gets" ); + writeln( "executed as" ); + writeln( "a whole" ); + } + } + // Notice here that the prints from each statement may happen in any order. + + // Coforall loop will create a new task for EACH iteration + var num_tasks = 10; // Number of tasks we want + coforall taskID in 1..#num_tasks { + writeln( "Hello from task# ", taskID ); + } + // Again we see that prints happen in any order. + // NOTE! coforall should be used only for creating tasks! + // Using it to iterating over a structure is very a bad idea! + + // forall loops are another parallel loop, but only create a smaller number + // of tasks, specifically --dataParTasksPerLocale=number of task + forall i in 1..100 { + write( i, ", "); + } + writeln( ); + // Here we see that there are sections that are in order, followed by + // a section that would not follow ( e.g. 1, 2, 3, 7, 8, 9, 4, 5, 6, ). + // This is because each task is taking on a chunk of the range 1..10 + // (1..3, 4..6, or 7..9) doing that chunk serially, but each task happens + // in parallel. + // Your results may depend on your machine and configuration + + // For both the forall and coforall loops, the execution of the + // parent task will not continue until all the children sync up. + + // forall loops are particularly useful for parallel iteration over arrays. + // Lets run an experiment to see how much faster a parallel loop is + use Time; // Import the Time module to use Timer objects + var timer: Timer; + var myBigArray: [{1..4000,1..4000}] real; // Large array we will write into + + // Serial Experiment + timer.start( ); // Start timer + for (x,y) in myBigArray.domain { // Serial iteration + myBigArray[x,y] = (x:real) / (y:real); + } + timer.stop( ); // Stop timer + writeln( "Serial: ", timer.elapsed( ) ); // Print elapsed time + timer.clear( ); // Clear timer for parallel loop + + // Parallel Experiment + timer.start( ); // start timer + forall (x,y) in myBigArray.domain { // Parallel iteration + myBigArray[x,y] = (x:real) / (y:real); + } + timer.stop( ); // Stop timer + writeln( "Parallel: ", timer.elapsed( ) ); // Print elapsed time + timer.clear( ); + // You may have noticed that (depending on how many cores you have) + // that the parallel loop went faster than the serial loop + + // The bracket style loop-expression described + // much earlier implicitly uses a forall loop. + [ val in myBigArray ] val = 1 / val; // Parallel operation + + // Atomic variables, common to many languages, are ones whose operations + // occur uninterupted. Multiple threads can both modify atomic variables + // and can know that their values are safe. + // Chapel atomic variables can be of type bool, int, uint, and real. + var uranium: atomic int; + uranium.write( 238 ); // atomically write a variable + writeln( uranium.read() ); // atomically read a variable + + // operations are described as functions, you could define your own operators. + uranium.sub( 3 ); // atomically subtract a variable + writeln( uranium.read() ); + + var replaceWith = 239; + var was = uranium.exchange( replaceWith ); + writeln( "uranium was ", was, " but is now ", replaceWith ); + + var isEqualTo = 235; + if ( uranium.compareExchange( isEqualTo, replaceWith ) ) { + writeln( "uranium was equal to ", isEqualTo, + " so replaced value with ", replaceWith ); + } else { + writeln( "uranium was not equal to ", isEqualTo, + " so value stays the same... whatever it was" ); + } + + sync { + begin { // Reader task + writeln( "Reader: waiting for uranium to be ", isEqualTo ); + uranium.waitFor( isEqualTo ); + writeln( "Reader: uranium was set (by someone) to ", isEqualTo ); + } + + begin { // Writer task + writeln( "Writer: will set uranium to the value ", isEqualTo, " in..." ); + countdown( 3 ); + uranium.write( isEqualTo ); + } + } + + // sync vars have two states: empty and full. + // If you read an empty variable or write a full variable, you are waited + // until the variable is full or empty again + var someSyncVar$: sync int; // varName$ is a convention not a law. + sync { + begin { // Reader task + writeln( "Reader: waiting to read." ); + var read_sync = someSyncVar$; + writeln( "Reader: value is ", read_sync ); + } + + begin { // Writer task + writeln( "Writer: will write in..." ); + countdown( 3 ); + someSyncVar$ = 123; + } + } + + // single vars can only be written once. A read on an unwritten single results + // in a wait, but when the variable has a value it can be read indefinitely + var someSingleVar$: single int; // varName$ is a convention not a law. + sync { + begin { // Reader task + writeln( "Reader: waiting to read." ); + for i in 1..5 { + var read_single = someSingleVar$; + writeln( "Reader: iteration ", i,", and the value is ", read_single ); + } + } + + begin { // Writer task + writeln( "Writer: will write in..." ); + countdown( 3 ); + someSingleVar$ = 5; // first and only write ever. + } + } + + // Heres an example of using atomics and a synch variable to create a + // count-down mutex (also known as a multiplexer) + var count: atomic int; // our counter + var lock$: sync bool; // the mutex lock + + count.write( 2 ); // Only let two tasks in at a time. + lock$.writeXF( true ); // Set lock$ to full (unlocked) + // Note: The value doesnt actually matter, just the state + // (full:unlocked / empty:locked) + // Also, writeXF() fills (F) the sync var regardless of its state (X) + + coforall task in 1..#5 { // Generate tasks + // Create a barrier + do{ + lock$; // Read lock$ (wait) + }while ( count.read() < 1 ); // Keep waiting until a spot opens up + + count.sub(1); // decrement the counter + lock$.writeXF( true ); // Set lock$ to full (signal) + + // Actual 'work' + writeln( "Task #", task, " doing work." ); + sleep( 2 ); + + count.add( 1 ); // Increment the counter + lock$.writeXF( true ); // Set lock$ to full (signal) + } + + // we can define the operations + * & | ^ && || min max minloc maxloc + // over an entire array using scans and reductions + // Reductions apply the operation over the entire array and + // result in a single value + var listOfValues: [1..10] int = [15,57,354,36,45,15,456,8,678,2]; + var sumOfValues = + reduce listOfValues; + var maxValue = max reduce listOfValues; // 'max' give just max value + + // 'maxloc' gives max value and index of the max value + // Note: We have to zip the array and domain together with the zip iterator + var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues, + listOfValues.domain); + + writeln( (sumOfValues, maxValue, idxOfMax, listOfValues[ idxOfMax ] ) ); + + // Scans apply the operation incrementally and return an array of the + // value of the operation at that index as it progressed through the + // array from array.domain.low to array.domain.high + var runningSumOfValues = + scan listOfValues; + var maxScan = max scan listOfValues; + writeln( runningSumOfValues ); + writeln( maxScan ); +} // end main() +``` + +Who is this tutorial for? +------------------------- + +This tutorial is for people who want to learn the ropes of chapel without having to hear about what fiber mixture the ropes are, or how they were braided, or how the braid configurations differ between one another. +It won't teach you how to develop amazingly performant code, and it's not exhaustive. +Refer to the [language specification](http://chapel.cray.com/language.html) and the [module documentation](http://chapel.cray.com/docs/latest/) for more details. + +Occasionally check back here and on the [Chapel site](http://chapel.cray.com) to see if more topics have been added or more tutorials created. + +### What this tutorial is lacking: + + * Exposition of the [standard modules](http://chapel.cray.com/docs/latest/modules/modules.html) + * Multiple Locales (distributed memory system) + * Records + * Parallel iterators + +Your input, questions, and discoveries are important to the developers! +----------------------------------------------------------------------- + +The Chapel language is still in-development (version 1.12.0), so there are occasional hiccups with performance and language features. +The more information you give the Chapel development team about issues you encounter or features you would like to see, the better the language becomes. +Feel free to email the team and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman). + +If you're really interested in the development of the compiler or contributing to the project, +[check out the master Github repository](https://github.com/chapel-lang/chapel). +It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0). + +Installing the Compiler +----------------------- + +Chapel can be built and installed on your average 'nix machine (and cygwin). +[Download the latest release version](https://github.com/chapel-lang/chapel/releases/) +and it's as easy as + + 1. `tar -xvf chapel-1.12.0.tar.gz` + 2. `cd chapel-1.12.0` + 3. `make` + 4. `source util/setchplenv.bash # or .sh or .csh or .fish` + +You will need to `source util/setchplenv.EXT` from within the Chapel directory (`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop that command in a script that will get executed on startup (like .bashrc). + +Chapel is easily installed with Brew for OS X + + 1. `brew update` + 2. `brew install chapel` + +Compiling Code +-------------- + +Builds like other compilers: + +`chpl myFile.chpl -o myExe` + +Notable arguments: + + * `--fast`: enables a number of optimizations and disables array bounds checks. Should only enable when application is stable. + * `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>` at compile-time. + * `--main-module <Module Name>`: use the main() procedure found in the module `<Module Name>` as the executable's main. + * `--module-dir <Directory>`: includes `<Directory>` in the module search path. diff --git a/clojure-macros.html.markdown b/clojure-macros.html.markdown new file mode 100644 index 00000000..d74f77cf --- /dev/null +++ b/clojure-macros.html.markdown @@ -0,0 +1,152 @@ +--- +language: "clojure macros" +filename: learnclojuremacros.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +--- + +As with all Lisps, Clojure's inherent [homoiconicity](https://en.wikipedia.org/wiki/Homoiconic) +gives you access to the full extent of the language to write code-generation routines +called "macros". Macros provide a powerful way to tailor the language to your needs. + +Be careful though. It's considered bad form to write a macro when a function will do. +Use a macro only when you need control over when or if the arguments to a form will +be evaluated. + +You'll want to be familiar with Clojure. Make sure you understand everything in +[Clojure in Y Minutes](/docs/clojure/). + +```clojure +;; Define a macro using defmacro. Your macro should output a list that can +;; be evaluated as clojure code. +;; +;; This macro is the same as if you wrote (reverse "Hello World") +(defmacro my-first-macro [] + (list reverse "Hello World")) + +;; Inspect the result of a macro using macroexpand or macroexpand-1. +;; +;; Note that the call must be quoted. +(macroexpand '(my-first-macro)) +;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World") + +;; You can eval the result of macroexpand directly: +(eval (macroexpand '(my-first-macro))) +; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; But you should use this more succinct, function-like syntax: +(my-first-macro) ; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; You can make things easier on yourself by using the more succinct quote syntax +;; to create lists in your macros: +(defmacro my-first-quoted-macro [] + '(reverse "Hello World")) + +(macroexpand '(my-first-quoted-macro)) +;; -> (reverse "Hello World") +;; Notice that reverse is no longer function object, but a symbol. + +;; Macros can take arguments. +(defmacro inc2 [arg] + (list + 2 arg)) + +(inc2 2) ; -> 4 + +;; But, if you try to do this with a quoted list, you'll get an error, because +;; the argument will be quoted too. To get around this, clojure provides a +;; way of quoting macros: `. Inside `, you can use ~ to get at the outer scope +(defmacro inc2-quoted [arg] + `(+ 2 ~arg)) + +(inc2-quoted 2) + +;; You can use the usual destructuring args. Expand list variables using ~@ +(defmacro unless [arg & body] + `(if (not ~arg) + (do ~@body))) ; Remember the do! + +(macroexpand '(unless true (reverse "Hello World"))) +;; -> +;; (if (clojure.core/not true) (do (reverse "Hello World"))) + +;; (unless) evaluates and returns its body if the first argument is false. +;; Otherwise, it returns nil + +(unless true "Hello") ; -> nil +(unless false "Hello") ; -> "Hello" + +;; Used without care, macros can do great evil by clobbering your vars +(defmacro define-x [] + '(do + (def x 2) + (list x))) + +(def x 4) +(define-x) ; -> (2) +(list x) ; -> (2) + +;; To avoid this, use gensym to get a unique identifier +(gensym 'x) ; -> x1281 (or some such thing) + +(defmacro define-x-safely [] + (let [sym (gensym 'x)] + `(do + (def ~sym 2) + (list ~sym)))) + +(def x 4) +(define-x-safely) ; -> (2) +(list x) ; -> (4) + +;; You can use # within ` to produce a gensym for each symbol automatically +(defmacro define-x-hygenically [] + `(do + (def x# 2) + (list x#))) + +(def x 4) +(define-x-hygenically) ; -> (2) +(list x) ; -> (4) + +;; It's typical to use helper functions with macros. Let's create a few to +;; help us support a (dumb) inline arithmetic syntax +(declare inline-2-helper) +(defn clean-arg [arg] + (if (seq? arg) + (inline-2-helper arg) + arg)) + +(defn apply-arg + "Given args [x (+ y)], return (+ x y)" + [val [op arg]] + (list op val (clean-arg arg))) + +(defn inline-2-helper + [[arg1 & ops-and-args]] + (let [ops (partition 2 ops-and-args)] + (reduce apply-arg (clean-arg arg1) ops))) + +;; We can test it immediately, without creating a macro +(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5)) + +; However, we'll need to make it a macro if we want it to be run at compile time +(defmacro inline-2 [form] + (inline-2-helper form))) + +(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1))) +; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1) + +(inline-2 (1 + (3 / 2) - (1 / 2) + 1)) +; -> 3 (actually, 3N, since the number got cast to a rational fraction with /) +``` + +### Further Reading + +Writing Macros from [Clojure for the Brave and True](http://www.braveclojure.com/) +[http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/) + +Official docs +[http://clojure.org/macros](http://clojure.org/macros) + +When to use macros? +[http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html) diff --git a/clojure.html.markdown b/clojure.html.markdown index 6baae0ce..a125d18f 100644 --- a/clojure.html.markdown +++ b/clojure.html.markdown @@ -22,7 +22,7 @@ and often automatically. ; Clojure is written in "forms", which are just ; lists of things inside parentheses, separated by whitespace. ; -; The clojure reader assumes that the first thing is a +; The clojure reader assumes that the first thing is a ; function or macro to call, and the rest are arguments. ; The first call in a file should be ns, to set the namespace @@ -63,7 +63,7 @@ and often automatically. ; If you want to create a literal list of data, use ' to stop it from ; being evaluated '(+ 1 2) ; => (+ 1 2) -; (shorthand for (quote (+ 1 2)) +; (shorthand for (quote (+ 1 2))) ; You can eval a quoted list (eval '(+ 1 2)) ; => 3 @@ -205,7 +205,7 @@ keymap ; => {:a 1, :c 3, :b 2} ;("a" stringmap) ; => Exception: java.lang.String cannot be cast to clojure.lang.IFn -; Retrieving a non-present value returns nil +; Retrieving a non-present key returns nil (stringmap "d") ; => nil ; Use assoc to add new keys to hash-maps @@ -341,7 +341,7 @@ keymap ; => {:a 1, :b 2, :c 3} (swap! my-atom assoc :a 1) ; Sets my-atom to the result of (assoc {} :a 1) (swap! my-atom assoc :b 2) ; Sets my-atom to the result of (assoc {:a 1} :b 2) - ; Use '@' to dereference the atom and get the value +; Use '@' to dereference the atom and get the value my-atom ;=> Atom<#...> (Returns the Atom object) @my-atom ; => {:a 1 :b 2} @@ -365,7 +365,7 @@ my-atom ;=> Atom<#...> (Returns the Atom object) ### Further Reading -This is far from exhaustive, but hopefully it's enought o get you on your feet. +This is far from exhaustive, but hopefully it's enough to get you on your feet. Clojure.org has lots of articles: [http://clojure.org/](http://clojure.org/) @@ -376,5 +376,5 @@ Clojuredocs.org has documentation with examples for most core functions: 4Clojure is a great way to build your clojure/FP skills: [http://www.4clojure.com/](http://www.4clojure.com/) -Clojure-doc.org (yeah, really) has a number of getting started articles: +Clojure-doc.org (yes, really) has a number of getting started articles: [http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/coffeescript.html.markdown b/coffeescript.html.markdown new file mode 100644 index 00000000..85a5f81f --- /dev/null +++ b/coffeescript.html.markdown @@ -0,0 +1,102 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +filename: coffeescript.coffee +--- + +CoffeeScript is a little language that compiles one-to-one into the equivalent JavaScript, and there is no interpretation at runtime. +As one of the succeeders of JavaScript, CoffeeScript tries its best to output readable, pretty-printed and smooth-running JavaScript codes working well in every JavaScript runtime. + +See also [the CoffeeScript website](http://coffeescript.org/), which has a complete tutorial on CoffeeScript. + +```coffeescript +# CoffeeScript is a hipster language. +# It goes with the trends of many modern languages. +# So comments are like Ruby and Python, they use number symbols. + +### +Block comments are like these, and they translate directly to '/ *'s and '* /'s +for the resulting JavaScript code. + +You should understand most of JavaScript semantics +before continuing. +### + +# Assignment: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# Conditions: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# Functions: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +fill = (container, liquid = "coffee") -> + "Filling the #{container} with #{liquid}..." +#=>var fill; +# +#fill = function(container, liquid) { +# if (liquid == null) { +# liquid = "coffee"; +# } +# return "Filling the " + container + " with " + liquid + "..."; +#}; + +# Ranges: +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# Objects: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Splats: +race = (winner, runners...) -> + print winner, runners +#=>race = function() { +# var runners, winner; +# winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(winner, runners); +#}; + +# Existence: +alert "I knew it!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# Array comprehensions: +cubes = (math.cube num for num in list) +#=>cubes = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +foods = ['broccoli', 'spinach', 'chocolate'] +eat food for food in foods when food isnt 'chocolate' +#=>foods = ['broccoli', 'spinach', 'chocolate']; +# +#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) { +# food = foods[_k]; +# if (food !== 'chocolate') { +# eat(food); +# } +#} +``` + +## Additional resources + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) diff --git a/common-lisp.html.markdown b/common-lisp.html.markdown new file mode 100644 index 00000000..63183c1e --- /dev/null +++ b/common-lisp.html.markdown @@ -0,0 +1,625 @@ +--- + +language: "Common Lisp" +filename: commonlisp.lisp +contributors: + - ["Paul Nathan", "https://github.com/pnathan"] +--- + +ANSI Common Lisp is a general purpose, multi-paradigm programming +language suited for a wide variety of industry applications. It is +frequently referred to as a programmable programming language. + +The classic starting point is [Practical Common Lisp and freely available.](http://www.gigamonkeys.com/book/) + +Another popular and recent book is +[Land of Lisp](http://landoflisp.com/). + + + +```common_lisp + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 0. Syntax +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; General form. + +;; Lisp has two fundamental pieces of syntax: the ATOM and the +;; S-expression. Typically, grouped S-expressions are called `forms`. + +10 ; an atom; it evaluates to itself + +:THING ;Another atom; evaluating to the symbol :thing. + +t ; another atom, denoting true. + +(+ 1 2 3 4) ; an s-expression + +'(4 :foo t) ;another one + + +;;; Comments + +;; Single line comments start with a semicolon; use two for normal +;; comments, three for section comments, and four for file-level +;; comments. + +#| Block comments + can span multiple lines and... + #| + they can be nested! + |# +|# + +;;; Environment. + +;; A variety of implementations exist; most are +;; standard-conformant. CLISP is a good starting one. + +;; Libraries are managed through Quicklisp.org's Quicklisp system. + +;; Common Lisp is usually developed with a text editor and a REPL +;; (Read Evaluate Print Loop) running at the same time. The REPL +;; allows for interactive exploration of the program as it is "live" +;; in the system. + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 1. Primitive Datatypes and Operators +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Symbols + +'foo ; => FOO Notice that the symbol is upper-cased automatically. + +;; Intern manually creates a symbol from a string. + +(intern "AAAA") ; => AAAA + +(intern "aaa") ; => |aaa| + +;;; Numbers +9999999999999999999999 ; integers +#b111 ; binary => 7 +#o111 ; octal => 73 +#x111 ; hexadecimal => 273 +3.14159s0 ; single +3.14159d0 ; double +1/2 ; ratios +#C(1 2) ; complex numbers + + +;; Function application is written (f x y z ...) +;; where f is a function and x, y, z, ... are operands +;; If you want to create a literal list of data, use ' to stop it from +;; being evaluated - literally, "quote" the data. +'(+ 1 2) ; => (+ 1 2) +;; You can also call a function manually: +(funcall #'+ 1 2 3) ; => 6 +;; Some arithmetic operations +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(mod 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(+ #C(1 2) #C(6 -4)) ; => #C(7 -2) + + ;;; Booleans +t ; for true (any not-nil value is true) +nil ; for false - and the empty list +(not nil) ; => t +(and 0 t) ; => t +(or 0 nil) ; => 0 + + ;;; Characters +#\A ; => #\A +#\λ ; => #\GREEK_SMALL_LETTER_LAMDA +#\u03BB ; => #\GREEK_SMALL_LETTER_LAMDA + +;;; Strings are fixed-length arrays of characters. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; backslash is an escaping character + +;; Strings can be concatenated too! +(concatenate 'string "Hello " "world!") ; => "Hello world!" + +;; A string can be treated like a sequence of characters +(elt "Apple" 0) ; => #\A + +;; format can be used to format strings: +(format nil "~a can be ~a" "strings" "formatted") + +;; Printing is pretty easy; ~% is the format specifier for newline. +(format t "Common Lisp is groovy. Dude.~%") + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variables +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; You can create a global (dynamically scoped) using defparameter +;; a variable name can use any character except: ()",'`;#|\ + +;; Dynamically scoped variables should have earmuffs in their name! + +(defparameter *some-var* 5) +*some-var* ; => 5 + +;; You can also use unicode characters. +(defparameter *AΛB* nil) + + +;; Accessing a previously unbound variable is an +;; undefined behavior (but possible). Don't do it. + + +;; Local binding: `me` is bound to "dance with you" only within the +;; (let ...). Let always returns the value of the last `form` in the +;; let form. + +(let ((me "dance with you")) + me) +;; => "dance with you" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Structs and Collections +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Structs +(defstruct dog name breed age) +(defparameter *rover* + (make-dog :name "rover" + :breed "collie" + :age 5)) +*rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5) + +(dog-p *rover*) ; => true #| -p signifies "predicate". It's used to + check if *rover* is an instance of dog. |# +(dog-name *rover*) ; => "rover" + +;; Dog-p, make-dog, and dog-name are all created by defstruct! + +;;; Pairs +;; `cons' constructs pairs, `car' and `cdr' extract the first +;; and second elements +(cons 'SUBJECT 'VERB) ; => '(SUBJECT . VERB) +(car (cons 'SUBJECT 'VERB)) ; => SUBJECT +(cdr (cons 'SUBJECT 'VERB)) ; => VERB + +;;; Lists + +;; Lists are linked-list data structures, made of `cons' pairs and end +;; with a `nil' (or '()) to mark the end of the list +(cons 1 (cons 2 (cons 3 nil))) ; => '(1 2 3) +;; `list' is a convenience variadic constructor for lists +(list 1 2 3) ; => '(1 2 3) +;; and a quote can also be used for a literal list value +'(1 2 3) ; => '(1 2 3) + +;; Can still use `cons' to add an item to the beginning of a list +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; Use `append' to - surprisingly - append lists together +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; Or use concatenate - + +(concatenate 'list '(1 2) '(3 4)) + +;; Lists are a very central type, so there is a wide variety of functionality for +;; them, a few examples: +(mapcar #'1+ '(1 2 3)) ; => '(2 3 4) +(mapcar #'+ '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4) +(every #'evenp '(1 2 3 4)) ; => nil +(some #'oddp '(1 2 3 4)) ; => T +(butlast '(subject verb object)) ; => (SUBJECT VERB) + + +;;; Vectors + +;; Vector's literals are fixed-length arrays +#(1 2 3) ; => #(1 2 3) + +;; Use concatenate to add vectors together +(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Arrays + +;; Both vectors and strings are special-cases of arrays. + +;; 2D arrays + +(make-array (list 2 2)) + +;; (make-array '(2 2)) works as well. + +; => #2A((0 0) (0 0)) + +(make-array (list 2 2 2)) + +; => #3A(((0 0) (0 0)) ((0 0) (0 0))) + +;; Caution- the default initial values are +;; implementation-defined. Here's how to define them: + +(make-array '(2) :initial-element 'unset) + +; => #(UNSET UNSET) + +;; And, to access the element at 1,1,1 - +(aref (make-array (list 2 2 2)) 1 1 1) + +; => 0 + +;;; Adjustable vectors + +;; Adjustable vectors have the same printed representation +;; as fixed-length vector's literals. + +(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3) + :adjustable t :fill-pointer t)) + +*adjvec* ; => #(1 2 3) + +;; Adding new element: +(vector-push-extend 4 *adjvec*) ; => 3 + +*adjvec* ; => #(1 2 3 4) + + + +;;; Naively, sets are just lists: + +(set-difference '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1) +(intersection '(1 2 3 4) '(4 5 6 7)) ; => 4 +(union '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1 4 5 6 7) +(adjoin 4 '(1 2 3 4)) ; => (1 2 3 4) + +;; But you'll want to use a better data structure than a linked list +;; for performant work! + +;;; Dictionaries are implemented as hash tables. + +;; Create a hash table +(defparameter *m* (make-hash-table)) + +;; set a value +(setf (gethash 'a *m*) 1) + +;; Retrieve a value +(gethash 'a *m*) ; => 1, t + +;; Detail - Common Lisp has multiple return values possible. gethash +;; returns t in the second value if anything was found, and nil if +;; not. + +;; Retrieving a non-present value returns nil + (gethash 'd *m*) ;=> nil, nil + +;; You can provide a default value for missing keys +(gethash 'd *m* :not-found) ; => :NOT-FOUND + +;; Let's handle the multiple return values here in code. + +(multiple-value-bind + (a b) + (gethash 'd *m*) + (list a b)) +; => (NIL NIL) + +(multiple-value-bind + (a b) + (gethash 'a *m*) + (list a b)) +; => (1 T) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Functions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `lambda' to create anonymous functions. +;; A function always returns the value of its last expression. +;; The exact printable representation of a function will vary... + +(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}> + +;; Use funcall to call lambda functions +(funcall (lambda () "Hello World")) ; => "Hello World" + +;; Or Apply +(apply (lambda () "Hello World") nil) ; => "Hello World" + +;; De-anonymize the function +(defun hello-world () + "Hello World") +(hello-world) ; => "Hello World" + +;; The () in the above is the list of arguments for the function +(defun hello (name) + (format nil "Hello, ~a " name)) + +(hello "Steve") ; => "Hello, Steve" + +;; Functions can have optional arguments; they default to nil + +(defun hello (name &optional from) + (if from + (format t "Hello, ~a, from ~a" name from) + (format t "Hello, ~a" name))) + + (hello "Jim" "Alpacas") ;; => Hello, Jim, from Alpacas + +;; And the defaults can be set... +(defun hello (name &optional (from "The world")) + (format t "Hello, ~a, from ~a" name from)) + +(hello "Steve") +; => Hello, Steve, from The world + +(hello "Steve" "the alpacas") +; => Hello, Steve, from the alpacas + + +;; And of course, keywords are allowed as well... usually more +;; flexible than &optional. + +(defun generalized-greeter (name &key (from "the world") (honorific "Mx")) + (format t "Hello, ~a ~a, from ~a" honorific name from)) + +(generalized-greeter "Jim") ; => Hello, Mx Jim, from the world + +(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr") +; => Hello, Mr Jim, from the alpacas you met last summer + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Equality +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Common Lisp has a sophisticated equality system. A couple are covered here. + +;; for numbers use `=' +(= 3 3.0) ; => t +(= 2 1) ; => nil + +;; for object identity (approximately) use `eql` +(eql 3 3) ; => t +(eql 3 3.0) ; => nil +(eql (list 3) (list 3)) ; => nil + +;; for lists, strings, and bit-vectors use `equal' +(equal (list 'a 'b) (list 'a 'b)) ; => t +(equal (list 'a 'b) (list 'b 'a)) ; => nil + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Control Flow +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Conditionals + +(if t ; test expression + "this is true" ; then expression + "this is false") ; else expression +; => "this is true" + +;; In conditionals, all non-nil values are treated as true +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'YEP + +;; `cond' chains a series of tests to select a result +(cond ((> 2 2) (error "wrong!")) + ((< 2 2) (error "wrong again!")) + (t 'ok)) ; => 'OK + +;; Typecase switches on the type of the value +(typecase 1 + (string :string) + (integer :int)) + +; => :int + +;;; Iteration + +;; Of course recursion is supported: + +(defun walker (n) + (if (zerop n) + :walked + (walker (1- n)))) + +(walker 5) ; => :walked + +;; Most of the time, we use DOLIST or LOOP + + +(dolist (i '(1 2 3 4)) + (format t "~a" i)) + +; => 1234 + +(loop for i from 0 below 10 + collect i) + +; => (0 1 2 3 4 5 6 7 8 9) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutation +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `setf' to assign a new value to an existing variable. This was +;; demonstrated earlier in the hash table example. + +(let ((variable 10)) + (setf variable 2)) + ; => 2 + + +;; Good Lisp style is to minimize destructive functions and to avoid +;; mutation when reasonable. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Classes and Objects +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; No more Animal classes, let's have Human-Powered Mechanical +;; Conveyances. + +(defclass human-powered-conveyance () + ((velocity + :accessor velocity + :initarg :velocity) + (average-efficiency + :accessor average-efficiency + :initarg :average-efficiency)) + (:documentation "A human powered conveyance")) + +;; defclass, followed by name, followed by the superclass list, +;; followed by slot list, followed by optional qualities such as +;; :documentation. + +;; When no superclass list is set, the empty list defaults to the +;; standard-object class. This *can* be changed, but not until you +;; know what you're doing. Look up the Art of the Metaobject Protocol +;; for more information. + +(defclass bicycle (human-powered-conveyance) + ((wheel-size + :accessor wheel-size + :initarg :wheel-size + :documentation "Diameter of the wheel.") + (height + :accessor height + :initarg :height))) + +(defclass recumbent (bicycle) + ((chain-type + :accessor chain-type + :initarg :chain-type))) + +(defclass unicycle (human-powered-conveyance) nil) + +(defclass canoe (human-powered-conveyance) + ((number-of-rowers + :accessor number-of-rowers + :initarg :number-of-rowers))) + + +;; Calling DESCRIBE on the human-powered-conveyance class in the REPL gives: + +(describe 'human-powered-conveyance) + +; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE +; [symbol] +; +; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS +; HUMAN-POWERED-CONVEYANCE>: +; Documentation: +; A human powered conveyance +; Direct superclasses: STANDARD-OBJECT +; Direct subclasses: UNICYCLE, BICYCLE, CANOE +; Not yet finalized. +; Direct slots: +; VELOCITY +; Readers: VELOCITY +; Writers: (SETF VELOCITY) +; AVERAGE-EFFICIENCY +; Readers: AVERAGE-EFFICIENCY +; Writers: (SETF AVERAGE-EFFICIENCY) + +;; Note the reflective behavior available to you! Common Lisp is +;; designed to be an interactive system + +;; To define a method, let's find out what our circumference of the +;; bike wheel turns out to be using the equation: C = d * pi + +(defmethod circumference ((object bicycle)) + (* pi (wheel-size object))) + +;; pi is defined in Lisp already for us! + +;; Let's suppose we find out that the efficiency value of the number +;; of rowers in a canoe is roughly logarithmic. This should probably be set +;; in the constructor/initializer. + +;; Here's how to initialize your instance after Common Lisp gets done +;; constructing it: + +(defmethod initialize-instance :after ((object canoe) &rest args) + (setf (average-efficiency object) (log (1+ (number-of-rowers object))))) + +;; Then to construct an instance and check the average efficiency... + +(average-efficiency (make-instance 'canoe :number-of-rowers 15)) +; => 2.7725887 + + + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Macros let you extend the syntax of the language + +;; Common Lisp doesn't come with a WHILE loop- let's add one. +;; If we obey our assembler instincts, we wind up with: + +(defmacro while (condition &body body) + "While `condition` is true, `body` is executed. + +`condition` is tested prior to each execution of `body`" + (let ((block-name (gensym)) (done (gensym))) + `(tagbody + ,block-name + (unless ,condition + (go ,done)) + (progn + ,@body) + (go ,block-name) + ,done))) + +;; Let's look at the high-level version of this: + + +(defmacro while (condition &body body) + "While `condition` is true, `body` is executed. + +`condition` is tested prior to each execution of `body`" + `(loop while ,condition + do + (progn + ,@body))) + +;; However, with a modern compiler, this is not required; the LOOP +;; form compiles equally well and is easier to read. + +;; Note that ``` is used, as well as `,` and `@`. ``` is a quote-type operator +;; known as quasiquote; it allows the use of `,` . `,` allows "unquoting" +;; variables. @ interpolates lists. + +;; Gensym creates a unique symbol guaranteed to not exist elsewhere in +;; the system. This is because macros are expanded at compile time and +;; variables declared in the macro can collide with variables used in +;; regular code. + +;; See Practical Common Lisp for more information on macros. +``` + + +## Further Reading + +[Keep moving on to the Practical Common Lisp book.](http://www.gigamonkeys.com/book/) + + +## Credits. + +Lots of thanks to the Scheme people for rolling up a great starting +point which could be easily moved to Common Lisp. + +- [Paul Khuong](https://github.com/pkhuong) for some great reviewing. diff --git a/compojure.html.markdown b/compojure.html.markdown new file mode 100644 index 00000000..32181e26 --- /dev/null +++ b/compojure.html.markdown @@ -0,0 +1,280 @@ +--- +category: tool +tool: compojure +contributors: + - ["Adam Bard", "http://adambard.com/"] +filename: learncompojure.clj +--- + +## Getting Started with Compojure + +Compojure is a DSL for *quickly* creating *performant* web applications +in Clojure with minimal effort: + +```clojure +(ns myapp.core + (:require [compojure.core :refer :all] + [org.httpkit.server :refer [run-server]])) ; httpkit is a server + +(defroutes myapp + (GET "/" [] "Hello World")) + +(defn -main [] + (run-server myapp {:port 5000})) +``` + +**Step 1:** Create a project with [Leiningen](http://leiningen.org/): + +``` +lein new myapp +``` + +**Step 2:** Put the above code in `src/myapp/core.clj` + +**Step 3:** Add some dependencies to `project.clj`: + +``` +[compojure "1.1.8"] +[http-kit "2.1.16"] +``` + +**Step 4:** Run: + +``` +lein run -m myapp.core +``` + +View at: <http://localhost:5000/> + +Compojure apps will run on any ring-compatible server, but we recommend +[http-kit](http://http-kit.org/) for its performance and +[massive concurrency](http://http-kit.org/600k-concurrent-connection-http-kit.html). + +### Routes + +In compojure, each route is an HTTP method paired with a URL-matching pattern, +an argument list, and a body. + +```clojure +(defroutes myapp + (GET "/" [] "Show something") + (POST "/" [] "Create something") + (PUT "/" [] "Replace something") + (PATCH "/" [] "Modify Something") + (DELETE "/" [] "Annihilate something") + (OPTIONS "/" [] "Appease something") + (HEAD "/" [] "Preview something")) +``` + +Compojure route definitions are just functions which +[accept request maps and return response maps](https://github.com/mmcgrana/ring/blob/master/SPEC): + +```clojure +(myapp {:uri "/" :request-method :post}) +; => {:status 200 +; :headers {"Content-Type" "text/html; charset=utf-8} +; :body "Create Something"} +``` + +The body may be a function, which must accept the request as a parameter: + +```clojure +(defroutes myapp + (GET "/" [] (fn [req] "Do something with req"))) +``` + +Or, you can just use the request directly: + +```clojure +(defroutes myapp + (GET "/" req "Do something with req")) +``` + +Route patterns may include named parameters: + +```clojure +(defroutes myapp + (GET "/hello/:name" [name] (str "Hello " name))) +``` + +You can adjust what each parameter matches by supplying a regex: + +```clojure +(defroutes myapp + (GET ["/file/:name.:ext" :name #".*", :ext #".*"] [name ext] + (str "File: " name ext))) +``` + +### Middleware + +Clojure uses [Ring](https://github.com/ring-clojure/ring) for routing. +Handlers are just functions that accept a request map and return a +response map (Compojure will turn strings into 200 responses for you). + +You can easily write middleware that wraps all or part of your +application to modify requests or responses: + +```clojure +(defroutes myapp + (GET "/" req (str "Hello World v" (:app-version req)))) + +(defn wrap-version [handler] + (fn [request] + (handler (assoc request :app-version "1.0.1")))) + +(defn -main [] + (run-server (wrap-version myapp) {:port 5000})) +``` + +[Ring-Defaults](https://github.com/ring-clojure/ring-defaults) provides some handy +middlewares for sites and apis, so add it to your dependencies: + +``` +[ring/ring-defaults "0.1.1"] +``` + +Then, you can import it in your ns: + +``` +(ns myapp.core + (:require [compojure.core :refer :all] + [ring.middleware.defaults :refer :all] + [org.httpkit.server :refer [run-server]])) +``` + +And use `wrap-defaults` to add the `site-defaults` middleware to your +app: + +``` +(defn -main [] + (run-server (wrap-defaults myapp site-defaults) {:port 5000})) +``` + +Now, your handlers may utilize query parameters: + +```clojure +(defroutes myapp + (GET "/posts" req + (let [title (get (:params req) :title) + author (get (:params req) :author)] + (str "Title: " title ", Author: " author)))) +``` + +Or, for POST and PUT requests, form parameters as well + +```clojure +(defroutes myapp + (POST "/posts" req + (let [title (get (:params req) :title) + author (get (:params req) :author)] + (str "Title: " title ", Author: " author)))) +``` + + +### Return values + +The return value of a route block determines the response body +passed on to the HTTP client, or at least the next middleware in the +ring stack. Most commonly, this is a string, as in the above examples. +But, you may also return a [response map](https://github.com/mmcgrana/ring/blob/master/SPEC): + +```clojure +(defroutes myapp + (GET "/" [] + {:status 200 :body "Hello World"}) + (GET "/is-403" [] + {:status 403 :body ""}) + (GET "/is-json" [] + {:status 200 :headers {"Content-Type" "application/json"} :body "{}"})) +``` + +### Static Files + +To serve up static files, use `compojure.route.resources`. +Resources will be served from your project's `resources/` folder. + +```clojure +(require '[compojure.route :as route]) + +(defroutes myapp + (GET "/") + (route/resources "/")) ; Serve static resources at the root path + +(myapp {:uri "/js/script.js" :request-method :get}) +; => Contents of resources/public/js/script.js +``` + +### Views / Templates + +To use templating with Compojure, you'll need a template library. Here are a few: + +#### [Stencil](https://github.com/davidsantiago/stencil) + +[Stencil](https://github.com/davidsantiago/stencil) is a [Mustache](http://mustache.github.com/) template library: + +```clojure +(require '[stencil.core :refer [render-string]]) + +(defroutes myapp + (GET "/hello/:name" [name] + (render-string "Hello {{name}}" {:name name}))) +``` + +You can easily read in templates from your resources directory. Here's a helper function + +```clojure +(require 'clojure.java.io) + +(defn read-template [filename] + (slurp (clojure.java.io/resource filename))) + +(defroutes myapp + (GET "/hello/:name" [name] + (render-string (read-template "templates/hello.html") {:name name}))) +``` + +#### [Selmer](https://github.com/yogthos/Selmer) + +[Selmer](https://github.com/yogthos/Selmer) is a Django and Jinja2-inspired templating language: + +```clojure +(require '[selmer.parser :refer [render-file]]) + +(defroutes myapp + (GET "/hello/:name" [name] + (render-file "templates/hello.html" {:name name}))) +``` + +#### [Hiccup](https://github.com/weavejester/hiccup) + +[Hiccup](https://github.com/weavejester/hiccup) is a library for representing HTML as Clojure code + +```clojure +(require '[hiccup.core :as hiccup]) + +(defroutes myapp + (GET "/hello/:name" [name] + (hiccup/html + [:html + [:body + [:h1 {:class "title"} + (str "Hello " name)]]]))) +``` + +#### [Markdown](https://github.com/yogthos/markdown-clj) + +[Markdown-clj](https://github.com/yogthos/markdown-clj) is a Markdown implementation. + +```clojure +(require '[markdown.core :refer [md-to-html-string]]) + +(defroutes myapp + (GET "/hello/:name" [name] + (md-to-html-string "## Hello, world"))) +``` + +Further reading: + +* [Official Compojure Documentation](https://github.com/weavejester/compojure/wiki) + +* [Clojure for the Brave and True](http://www.braveclojure.com/) diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown new file mode 100644 index 00000000..11c8a654 --- /dev/null +++ b/cs-cz/python3.html.markdown @@ -0,0 +1,636 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] + - ["Steven Basart", "http://github.com/xksteven"] + - ["Andre Polykanine", "https://github.com/Oire"] + - ["Tomáš Bedřich", "http://tbedrich.cz"] +translators: + - ["Tomáš Bedřich", "http://tbedrich.cz"] +filename: learnpython3.py +lang: cs-cz +--- + +Python byl vytvořen Guidem Van Rossum v raných 90. letech. Nyní je jedním z nejpopulárnějších jazyků. +Zamiloval jsem si Python pro jeho syntaktickou čistotu - je to vlastně spustitelný pseudokód. + +Vaše zpětná vazba je vítána! Můžete mě zastihnout na [@louiedinh](http://twitter.com/louiedinh) nebo louiedinh [at] [email od googlu] anglicky, +autora českého překladu pak na [@tbedrich](http://twitter.com/tbedrich) nebo ja [at] tbedrich.cz + +Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/python/). + +```python + +# Jednořádkový komentář začíná křížkem + +""" Víceřádkové komentáře používají tři uvozovky nebo apostrofy + a jsou často využívány jako dokumentační komentáře k metodám +""" + +#################################################### +## 1. Primitivní datové typy a operátory +#################################################### + +# Čísla +3 # => 3 + +# Aritmetické operace se chovají běžným způsobem +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 + +# Až na dělení, které vrací desetinné číslo +35 / 5 # => 7.0 + +# Při celočíselném dělení je desetinná část oříznuta (pro kladná i záporná čísla) +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # celočíselně dělit lze i desetinným číslem +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Pokud použiteje desetinné číslo, výsledek je jím také +3 * 2.0 # => 6.0 + +# Modulo +7 % 3 # => 1 + +# Mocnění (x na y-tou) +2**4 # => 16 + +# Pro vynucení priority použijte závorky +(1 + 3) * 2 # => 8 + +# Logické hodnoty +True +False + +# Negace se provádí pomocí not +not True # => False +not False # => True + +# Logické operátory +# U operátorů záleží na velikosti písmen +True and False # => False +False or True # => True + +# Používání logických operátorů s čísly +0 and 2 # => 0 +-5 or 0 # => -5 +0 == False # => True +2 == True # => False +1 == True # => True + +# Rovnost je == +1 == 1 # => True +2 == 1 # => False + +# Nerovnost je != +1 != 1 # => False +2 != 1 # => True + +# Další porovnání +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Porovnání se dají řetězit! +1 < 2 < 3 # => True +2 < 3 < 2 # => False + + +# Řetězce používají " nebo ' a mohou obsahovat UTF8 znaky +"Toto je řetězec." +'Toto je také řetězec.' + +# Řetězce se také dají sčítat, ale nepoužívejte to +"Hello " + "world!" # => "Hello world!" +# Dají se spojovat i bez '+' +"Hello " "world!" # => "Hello world!" + +# Řetězec lze považovat za seznam znaků +"Toto je řetězec"[0] # => 'T' + +# .format lze použít ke skládání řetězců +"{} mohou být {}".format("řetězce", "skládány") + +# Formátovací argumenty můžete opakovat +"{0} {1} stříkaček stříkalo přes {0} {1} střech".format("tři sta třicet tři", "stříbrných") +# => "tři sta třicet tři stříbrných stříkaček stříkalo přes tři sta třicet tři stříbrných střech" + +# Pokud nechcete počítat, můžete použít pojmenované argumenty +"{jmeno} si dal {jidlo}".format(jmeno="Franta", jidlo="guláš") # => "Franta si dal guláš" + +# Pokud zároveň potřebujete podporovat Python 2.5 a nižší, můžete použít starší způsob formátování +"%s se dají %s jako v %s" % ("řetězce", "skládat", "jazyce C") + + +# None je objekt (jinde NULL, nil, ...) +None # => None + +# Pokud porovnáváte něco s None, nepoužívejte operátor rovnosti "==", +# použijte raději operátor "is", který testuje identitu. +"něco" is None # => False +None is None # => True + +# None, 0, a prázdný řetězec/seznam/slovník se vyhodnotí jako False +# Vše ostatní se vyhodnotí jako True +bool(0) # => False +bool("") # => False +bool([]) # => False +bool({}) # => False + + +#################################################### +## 2. Proměnné a kolekce +#################################################### + +# Python má funkci print +print("Jsem 3. Python 3.") + +# Proměnné není třeba deklarovat před přiřazením +# Konvence je používat male_pismo_s_podtrzitky +nazev_promenne = 5 +nazev_promenne # => 5 +# Názvy proměnných mohou obsahovat i UTF8 znaky +název_proměnné = 5 + +# Přístup k předtím nepoužité proměnné vyvolá výjimku +# Odchytávání vyjímek - viz další kapitola +neznama_promenna # Vyhodí NameError + +# Seznam se používá pro ukládání sekvencí +sez = [] +# Lze ho rovnou naplnit +jiny_seznam = [4, 5, 6] + +# Na konec seznamu se přidává pomocí append +sez.append(1) # sez je nyní [1] +sez.append(2) # sez je nyní [1, 2] +sez.append(4) # sez je nyní [1, 2, 4] +sez.append(3) # sez je nyní [1, 2, 4, 3] +# Z konce se odebírá se pomocí pop +sez.pop() # => 3 a sez je nyní [1, 2, 4] +# Vložme trojku zpátky +sez.append(3) # sez je nyní znovu [1, 2, 4, 3] + +# Přístup k prvkům funguje jako v poli +sez[0] # => 1 +# Mínus počítá odzadu (-1 je poslední prvek) +sez[-1] # => 3 + +# Přístup mimo seznam vyhodí IndexError +sez[4] # Vyhodí IndexError + +# Pomocí řezů lze ze seznamu vybírat různé intervaly +# (pro matematiky: jedná se o uzavřený/otevřený interval) +sez[1:3] # => [2, 4] +# Odříznutí začátku +sez[2:] # => [4, 3] +# Odříznutí konce +sez[:3] # => [1, 2, 4] +# Vybrání každého druhého prvku +sez[::2] # =>[1, 4] +# Vrácení seznamu v opačném pořadí +sez[::-1] # => [3, 4, 2, 1] +# Lze použít jakoukoliv kombinaci parametrů pro vytvoření složitějšího řezu +# sez[zacatek:konec:krok] + +# Odebírat prvky ze seznamu lze pomocí del +del sez[2] # sez je nyní [1, 2, 3] + +# Seznamy můžete sčítat +# Hodnoty sez a jiny_seznam přitom nejsou změněny +sez + jiny_seznam # => [1, 2, 3, 4, 5, 6] + +# Spojit seznamy lze pomocí extend +sez.extend(jiny_seznam) # sez je nyní [1, 2, 3, 4, 5, 6] + +# Kontrola, jestli prvek v seznamu existuje, se provádí pomocí in +1 in sez # => True + +# Délku seznamu lze zjistit pomocí len +len(sez) # => 6 + + +# N-tice je jako seznam, ale je neměnná +ntice = (1, 2, 3) +ntice[0] # => 1 +ntice[0] = 3 # Vyhodí TypeError + +# S n-ticemi lze dělat většinu operací, jako se seznamy +len(ntice) # => 3 +ntice + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +ntice[:2] # => (1, 2) +2 in ntice # => True + +# N-tice (nebo seznamy) lze rozbalit do proměnných jedním přiřazením +a, b, c = (1, 2, 3) # a je nyní 1, b je nyní 2 a c je nyní 3 +# N-tice jsou vytvářeny automaticky, když vynecháte závorky +d, e, f = 4, 5, 6 +# Prohození proměnných je tak velmi snadné +e, d = d, e # d je nyní 5, e je nyní 4 + + +# Slovníky ukládají klíče a hodnoty +prazdny_slovnik = {} +# Lze je také rovnou naplnit +slovnik = {"jedna": 1, "dva": 2, "tři": 3} + +# Přistupovat k hodnotám lze pomocí [] +slovnik["jedna"] # => 1 + +# Všechny klíče dostaneme pomocí keys() jako iterovatelný objekt. Nyní ještě +# potřebujeme obalit volání v list(), abychom dostali seznam. To rozebereme +# později. Pozor, že jakékoliv pořadí klíčů není garantováno - může být různé. +list(slovnik.keys()) # => ["dva", "jedna", "tři"] + +# Všechny hodnoty opět jako iterovatelný objekt získáme pomocí values(). Opět +# tedy potřebujeme použít list(), abychom dostali seznam. Stejně jako +# v předchozím případě, pořadí není garantováno a může být různé +list(slovnik.values()) # => [3, 2, 1] + +# Operátorem in se lze dotázat na přítomnost klíče +"jedna" in slovnik # => True +1 in slovnik # => False + +# Přístup k neexistujícímu klíči vyhodí KeyError +slovnik["čtyři"] # Vyhodí KeyError + +# Metoda get() funguje podobně jako [], ale vrátí None místo vyhození KeyError +slovnik.get("jedna") # => 1 +slovnik.get("čtyři") # => None +# Metodě get() lze předat i výchozí hodnotu místo None +slovnik.get("jedna", 4) # => 1 +slovnik.get("čtyři", 4) # => 4 + +# metoda setdefault() vloží prvek do slovníku pouze pokud tam takový klíč není +slovnik.setdefault("pět", 5) # slovnik["pět"] je nastaven na 5 +slovnik.setdefault("pět", 6) # slovnik["pět"] je pořád 5 + +# Přidání nové hodnoty do slovníku +slovnik["čtyři"] = 4 +# Hromadně aktualizovat nebo přidat data lze pomocí update(), parametrem je opět slovník +slovnik.update({"čtyři": 4}) # slovnik je nyní {"jedna": 1, "dva": 2, "tři": 3, "čtyři": 4, "pět": 5} + +# Odebírat ze slovníku dle klíče lze pomocí del +del slovnik["jedna"] # odebere klíč "jedna" ze slovnik + + +# Množiny ukládají ... překvapivě množiny +prazdna_mnozina = set() +# Také je lze rovnou naplnit. A ano, budou se vám plést se slovníky. Bohužel. +mnozina = {1, 1, 2, 2, 3, 4} # mnozina je nyní {1, 2, 3, 4} + +# Přidání položky do množiny +mnozina.add(5) # mnozina je nyní {1, 2, 3, 4, 5} + +# Průnik lze udělat pomocí operátoru & +jina_mnozina = {3, 4, 5, 6} +mnozina & jina_mnozina # => {3, 4, 5} + +# Sjednocení pomocí operátoru | +mnozina | jina_mnozina # => {1, 2, 3, 4, 5, 6} + +# Rozdíl pomocí operátoru - +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Operátorem in se lze dotázat na přítomnost prvku v množině +2 in mnozina # => True +9 in mnozina # => False + + +#################################################### +## 3. Řízení toku programu, cykly +#################################################### + +# Vytvořme si proměnnou +promenna = 5 + +# Takto vypadá podmínka. Na odsazení v Pythonu záleží! +# Vypíše "proměnná je menší než 10". +if promenna > 10: + print("proměnná je velká jak Rusko") +elif promenna < 10: # Část elif je nepovinná + print("proměnná je menší než 10") +else: # Část else je také nepovinná + print("proměnná je právě 10") + + +""" +Smyčka for umí iterovat (nejen) přes seznamy +vypíše: + pes je savec + kočka je savec + myš je savec +""" +for zvire in ["pes", "kočka", "myš"]: + # Můžete použít formát pro složení řetězce + print("{} je savec".format(zvire)) + +""" +range(cislo) vrací iterovatelný objekt čísel od 0 do cislo +vypíše: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +range(spodni_limit, horni_limit) vrací iterovatelný objekt čísel mezi limity +vypíše: + 4 + 5 + 6 + 7 +""" +for i in range(4, 8): + print(i) + +""" +Smyčka while se opakuje, dokud je podmínka splněna. +vypíše: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Zkrácený zápis x = x + 1. Pozor, žádné x++ neexisuje. + + +# Výjimky lze ošetřit pomocí bloku try/except(/else/finally) +try: + # Pro vyhození výjimky použijte raise + raise IndexError("Přistoupil jste k neexistujícímu prvku v seznamu.") +except IndexError as e: + print("Nastala chyba: {}".format(e)) + # Vypíše: Nastala chyba: Přistoupil jste k neexistujícímu prvku v seznamu. +except (TypeError, NameError): # Více výjimek lze zachytit najednou + pass # Pass znamená nedělej nic - nepříliš vhodný způsob ošetření chyb +else: # Volitelný blok else musí být až za bloky except + print("OK!") # Vypíše OK! v případě, že nenastala žádná výjimka +finally: # Blok finally se spustí nakonec za všech okolností + print("Uvolníme zdroje, uzavřeme soubory...") + +# Místo try/finally lze použít with pro automatické uvolnění zdrojů +with open("soubor.txt") as soubor: + for radka in soubor: + print(radka) + +# Python běžně používá iterovatelné objekty, což je prakticky cokoliv, +# co lze považovat za sekvenci. Například to, co vrací metoda range(), +# nebo otevřený soubor, jsou iterovatelné objekty. + +slovnik = {"jedna": 1, "dva": 2, "tři": 3} +iterovatelny_objekt = slovnik.keys() +print(iterovatelny_objekt) # => dict_keys(["jedna", "dva", "tři"]). Toto je iterovatelný objekt. + +# Můžeme použít cyklus for na jeho projití +for klic in iterovatelny_objekt: + print(klic) # vypíše postupně: jedna, dva, tři + +# Ale nelze přistupovat k prvkům pod jejich indexem +iterovatelny_objekt[1] # Vyhodí TypeError + +# Všechny položky iterovatelného objektu lze získat jako seznam pomocí list() +list(slovnik.keys()) # => ["jedna", "dva", "tři"] + +# Z iterovatelného objektu lze vytvořit iterátor +iterator = iter(iterovatelny_objekt) + +# Iterátor je objekt, který si pamatuje stav v rámci svého iterovatelného objektu +# Další hodnotu dostaneme voláním next() +next(iterator) # => "jedna" + +# Iterátor si udržuje svůj stav v mezi jednotlivými voláními next() +next(iterator) # => "dva" +next(iterator) # => "tři" + +# Jakmile interátor vrátí všechna svá data, vyhodí výjimku StopIteration +next(iterator) # Vyhodí StopIteration + + +#################################################### +## 4. Funkce +#################################################### + +# Pro vytvoření nové funkce použijte def +def secist(x, y): + print("x je {} a y je {}".format(x, y)) + return x + y # Hodnoty se vrací pomocí return + +# Volání funkce s parametry +secist(5, 6) # => Vypíše "x je 5 a y je 6" a vrátí 11 + +# Jiný způsob, jak volat funkci, je použít pojmenované argumenty +secist(y=6, x=5) # Pojmenované argumenty můžete předat v libovolném pořadí + +# Lze definovat funkce s proměnným počtem (pozičních) argumentů +def vrat_argumenty(*argumenty): + return argumenty + +vrat_argumenty(1, 2, 3) # => (1, 2, 3) + +# Lze definovat také funkce s proměnným počtem pojmenovaných argumentů +def vrat_pojmenovane_argumenty(**pojmenovane_argumenty): + return pojmenovane_argumenty + +vrat_pojmenovane_argumenty(kdo="se bojí", nesmi="do lesa") +# => {"kdo": "se bojí", "nesmi": "do lesa"} + + +# Pokud chcete, lze použít obojí najednou +# Konvence je používat pro tyto účely názvy *args a **kwargs +def vypis_vse(*args, **kwargs): + print(args, kwargs) # print() vypíše všechny své parametry oddělené mezerou + +vypis_vse(1, 2, a=3, b=4) # Vypíše: (1, 2) {"a": 3, "b": 4} + +# * nebo ** lze použít k rozbalení N-tic nebo slovníků! +ntice = (1, 2, 3, 4) +slovnik = {"a": 3, "b": 4} +vypis_vse(ntice) # Vyhodnotí se jako vypis_vse((1, 2, 3, 4)) – jeden parametr, N-tice +vypis_vse(*ntice) # Vyhodnotí se jako vypis_vse(1, 2, 3, 4) +vypis_vse(**slovnik) # Vyhodnotí se jako vypis_vse(a=3, b=4) +vypis_vse(*ntice, **slovnik) # Vyhodnotí se jako vypis_vse(1, 2, 3, 4, a=3, b=4) + + +# Viditelnost proměnných - vytvořme si globální proměnnou x +x = 5 + +def nastavX(cislo): + # Lokální proměnná x překryje globální x + x = cislo # => 43 + print(x) # => 43 + +def nastavGlobalniX(cislo): + global x + print(x) # => 5 + x = cislo # Nastaví globální proměnnou x na 6 + print(x) # => 6 + +nastavX(43) +nastavGlobalniX(6) + + +# Funkce jsou first-class objekty +def vyrobit_scitacku(pricitane_cislo): + def scitacka(x): + return x + pricitane_cislo + return scitacka + +pricist_10 = vyrobit_scitacku(10) +pricist_10(3) # => 13 + +# Klíčové slovo lambda vytvoří anonymní funkci +(lambda parametr: parametr > 2)(3) # => True + +# Lze použít funkce map() a filter() z funkcionálního programování +map(pricist_10, [1, 2, 3]) +# => <map object at 0x0123467> - iterovatelný objekt s obsahem: [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) +# => <filter object at 0x0123467> - iterovatelný objekt s obsahem: [6, 7] + +# S generátorovou notací lze dosáhnout podobných výsledků, ale vrací seznam +[pricist_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] +# Generátorová notace funguje i pro slovníky +{x: x**2 for x in range(1, 5)} # => {1: 1, 2: 4, 3: 9, 4: 16} +# A také pro množiny +{pismeno for pismeno in "abeceda"} # => {"d", "a", "c", "e", "b"} + + +#################################################### +## 5. Třídy +#################################################### + +# Třída Clovek je potomkem (dědí od) třídy object +class Clovek(object): + + # Atribut třídy - je sdílený všemi instancemi + druh = "H. sapiens" + + # Toto je kostruktor. Je volán, když vytváříme instanci třídy. Dvě + # podtržítka na začátku a na konci značí, že se jedná o atribut nebo + # objekt využívaný Pythonem ke speciálním účelům, ale můžete sami + # definovat jeho chování. Metody jako __init__, __str__, __repr__ + # a další se nazývají "magické metody". Nikdy nepoužívejte toto + # speciální pojmenování pro běžné metody. + def __init__(self, jmeno): + # Přiřazení parametru do atributu instance jmeno + self.jmeno = jmeno + + # Metoda instance - všechny metody instance mají "self" jako první parametr + def rekni(self, hlaska): + return "{jmeno}: {hlaska}".format(jmeno=self.jmeno, hlaska=hlaska) + + # Metoda třídy - sdílená všemi instancemi + # Dostává jako první parametr třídu, na které je volána + @classmethod + def vrat_druh(cls): + return cls.druh + + # Statická metoda je volána bez reference na třídu nebo instanci + @staticmethod + def odkaslej_si(): + return "*ehm*" + + +# Vytvoření instance +d = Clovek(jmeno="David") +a = Clovek("Adéla") +print(d.rekni("ahoj")) # Vypíše: "David: ahoj" +print(a.rekni("nazdar")) # Vypíše: "Adéla: nazdar" + +# Volání třídní metody +d.vrat_druh() # => "H. sapiens" + +# Změna atributu třídy +Clovek.druh = "H. neanderthalensis" +d.vrat_druh() # => "H. neanderthalensis" +a.vrat_druh() # => "H. neanderthalensis" + +# Volání statické metody +Clovek.odkaslej_si() # => "*ehm*" + + +#################################################### +## 6. Moduly +#################################################### + +# Lze importovat moduly +import math +print(math.sqrt(16)) # => 4 + +# Lze také importovat pouze vybrané funkce z modulu +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# Můžete také importovat všechny funkce z modulu, ale radši to nedělejte +from math import * + +# Můžete si přejmenovat modul při jeho importu +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Modul v Pythonu není nic jiného, než obyčejný soubor .py +# Můžete si napsat vlastní a prostě ho importovat podle jména +from muj_modul import moje_funkce # Nyní vyhodí ImportError - muj_modul neexistuje + +# Funkcí dir() lze zjistit, co modul obsahuje +import math +dir(math) + + +#################################################### +## 7. Pokročilé +#################################################### + +# Generátory jsou funkce, které místo return obsahují yield +def nasobicka_2(sekvence): + for i in sekvence: + yield 2 * i + +# Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil +# celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci. +# To znamená, že čísla větší než 15 se v metodě nasobicka_2 vůbec nezpracují. + +# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo +# hodně času i paměti, proto se místo toho čísla generují postupně. + +for i in nasobicka_2(range(900000000)): + print(i) # Vypíše čísla 0, 2, 4, 6, 8, ... 30 + if i >= 30: + break + + +# Dekorátory jsou funkce, které se používají pro obalení jiné funkce, čímž mohou +# přidávat nebo měnit její stávající chování. Funkci dostávají jako parametr +# a typicky místo ní vrací jinou, která uvnitř volá tu původní. + +def nekolikrat(puvodni_funkce): + def opakovaci_funkce(*args, **kwargs): + for i in range(3): + puvodni_funkce(*args, **kwargs) + + return opakovaci_funkce + + +@nekolikrat +def pozdrav(jmeno): + print("Měj se {}!".format(jmeno)) + +pozdrav("Pepo") # Vypíše 3x: Měj se Pepo! +``` + +## Co dál? + +Spoustu odkazů na české i anglické materiály najdete na [webu české Python komunity] +(http://python.cz/). Můžete také přijít na Pyvo, kde to společně probereme. diff --git a/csharp.html.markdown b/csharp.html.markdown new file mode 100644 index 00000000..02650038 --- /dev/null +++ b/csharp.html.markdown @@ -0,0 +1,899 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] + - ["Melvyn Laïly", "http://x2a.yt"] + - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] + - ["Wouter Van Schandevijl", "http://github.com/laoujin"] +filename: LearnCSharp.cs +--- + +C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework. + +[Read more here.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx) + +```c# +// Single-line comments start with // +/* +Multi-line comments look like this +*/ +/// <summary> +/// This is an XML documentation comment which can be used to generate external +/// documentation or provide context help within an IDE +/// </summary> +//public void MethodOrClassOrOtherWithParsableHelp() {} + +// Specify the namespaces this source code will be using +// The namespaces below are all part of the standard .NET Framework Class Libary +using System; +using System.Collections.Generic; +using System.Dynamic; +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using System.IO; + +// But this one is not: +using System.Data.Entity; +// In order to be able to use it, you need to add a dll reference +// This can be done with the NuGet package manager: `Install-Package EntityFramework` + +// Namespaces define scope to organize code into "packages" or "modules" +// Using this code from another source file: using Learning.CSharp; +namespace Learning.CSharp +{ + // Each .cs file should at least contain a class with the same name as the file + // you're allowed to do otherwise, but shouldn't for sanity. + public class LearnCSharp + { + // BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before + public static void Syntax() + { + // Use Console.WriteLine to print lines + Console.WriteLine("Hello World"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // To print without a new line, use Console.Write + Console.Write("Hello "); + Console.Write("World"); + + /////////////////////////////////////////////////// + // Types & Variables + // + // Declare a variable using <type> <name> + /////////////////////////////////////////////////// + + // Sbyte - Signed 8-bit integer + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Unsigned 8-bit integer + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - 16-bit integer + // Signed - (-32,768 <= short <= 32,767) + // Unsigned - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Integer - 32-bit integer + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - 64-bit integer + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // Numbers default to being int or uint depending on size. + // L is used to denote that this variable value is of type long or ulong + + // Double - Double-precision 64-bit IEEE 754 Floating Point + double fooDouble = 123.4; // Precision: 15-16 digits + + // Float - Single-precision 32-bit IEEE 754 Floating Point + float fooFloat = 234.5f; // Precision: 7 digits + // f is used to denote that this variable value is of type float + + // Decimal - a 128-bits data type, with more precision than other floating-point types, + // suited for financial and monetary calculations + decimal fooDecimal = 150.3m; + + // Boolean - true & false + bool fooBoolean = true; // or false + + // Char - A single 16-bit Unicode character + char fooChar = 'A'; + + // Strings -- unlike the previous base types which are all value types, + // a string is a reference type. That is, you can set it to null + string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; + Console.WriteLine(fooString); + + // You can access each character of the string with an indexer: + char charFromString = fooString[1]; // => 'e' + // Strings are immutable: you can't do fooString[1] = 'X'; + + // Compare strings with current culture, ignoring case + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // Formatting, based on sprintf + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // Dates & Formatting + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // You can split a string over two lines with the @ symbol. To escape " use "" + string bazString = @"Here's some stuff +on a new line! ""Wow!"", the masses cried"; + + // Use const or read-only to make a variable immutable + // const values are calculated at compile time + const int HoursWorkPerWeek = 9001; + + /////////////////////////////////////////////////// + // Data Structures + /////////////////////////////////////////////////// + + // Arrays - zero indexed + // The array size must be decided upon declaration + // The format for declaring an array is follows: + // <datatype>[] <var name> = new <datatype>[<array size>]; + int[] intArray = new int[10]; + + // Another way to declare & initialize an array + int[] y = { 9000, 1000, 1337 }; + + // Indexing an array - Accessing an element + Console.WriteLine("intArray @ 0: " + intArray[0]); + // Arrays are mutable. + intArray[1] = 1; + + // Lists + // Lists are used more frequently than arrays as they are more flexible + // The format for declaring a list is follows: + // List<datatype> <var name> = new List<datatype>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize + // The <> are for generics - Check out the cool stuff section + + // Lists don't default to a value; + // A value must be added before accessing the index + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + // Others data structures to check out: + // Stack/Queue + // Dictionary (an implementation of a hash map) + // HashSet + // Read-only Collections + // Tuple (.Net 4+) + + /////////////////////////////////////// + // Operators + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // Shorthand for multiple declarations + + // Arithmetic is straightforward + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // Modulo + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Comparison operators + Console.WriteLine("3 == 2? " + (3 == 2)); // => false + Console.WriteLine("3 != 2? " + (3 != 2)); // => true + Console.WriteLine("3 > 2? " + (3 > 2)); // => true + Console.WriteLine("3 < 2? " + (3 < 2)); // => false + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true + + // Bitwise operators! + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR + */ + + // Incrementations + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. Post-Incrementation + Console.WriteLine(++i); //i = 2. Pre-Incrementation + Console.WriteLine(i--); //i = 1. Post-Decrementation + Console.WriteLine(--i); //i = 0. Pre-Decrementation + + /////////////////////////////////////// + // Control Structures + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // If statements are c-like + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // Ternary operators + // A simple if/else can be written as follows + // <condition> ? <true> : <false> + int toCompare = 17; + string isTrue = toCompare == 17 ? "True" : "False"; + + // While loop + int fooWhile = 0; + while (fooWhile < 100) + { + //Iterated 100 times, fooWhile 0->99 + fooWhile++; + } + + // Do While Loop + int fooDoWhile = 0; + do + { + // Start iteration 100 times, fooDoWhile 0->99 + if (false) + continue; // skip the current iteration + + fooDoWhile++; + + if (fooDoWhile == 50) + break; // breaks from the loop completely + + } while (fooDoWhile < 100); + + //for loop structure => for(<start_statement>; <conditional>; <step>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + //Iterated 10 times, fooFor 0->9 + } + + // For Each Loop + // foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>) + // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T> + // All the collection types (Array, List, Dictionary...) in the .Net framework + // implement one or both of these interfaces. + // (The ToCharArray() could be removed, because a string also implements IEnumerable) + foreach (char character in "Hello World".ToCharArray()) + { + //Iterated over all the characters in the string + } + + // Switch Case + // A switch works with the byte, short, char, and int data types. + // It also works with enumerated types (discussed in Enum Types), + // the String class, and a few special classes that wrap + // primitive types: Character, Byte, Short, and Integer. + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + // You can assign more than one case to an action + // But you can't add an action without a break before another case + // (if you want to do this, you would have to explicitly add a goto case x + case 6: + case 7: + case 8: + monthString = "Summer time!!"; + break; + default: + monthString = "Some other month"; + break; + } + + /////////////////////////////////////// + // Converting Data Types And Typecasting + /////////////////////////////////////// + + // Converting data + + // Convert String To Integer + // this will throw a FormatException on failure + int.Parse("123");//returns an integer version of "123" + + // try parse will default to type default on failure + // in this case: 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // Function is boolean + Console.WriteLine(tryInt); // 123 + + // Convert Integer To String + // Convert class has a number of methods to facilitate conversions + Convert.ToString(123); + // or + tryInt.ToString(); + + // Casting + // Cast decimal 15 to a int + // and then implicitly cast to long + long x = (int) 15M; + } + + /////////////////////////////////////// + // CLASSES - see definitions at end of file + /////////////////////////////////////// + public static void Classes() + { + // See Declaration of objects at end of file + + // Use new to instantiate a class + Bicycle trek = new Bicycle(); + + // Call object methods + trek.SpeedUp(3); // You should always use setter and getter methods + trek.Cadence = 100; + + // ToString is a convention to display the value of this Object. + Console.WriteLine("trek info: " + trek.Info()); + + // Instantiate a new Penny Farthing + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } // End main method + + // CONSOLE ENTRY A console application must have a main method as an entry point + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // INTERESTING FEATURES + // + + // DEFAULT METHOD SIGNATURES + + public // Visibility + static // Allows for direct call on class without object + int // Return Type, + MethodSignatures( + int maxCount, // First variable, expects an int + int count = 0, // will default the value to 0 if not passed in + int another = 3, + params string[] otherParams // captures all other parameters passed to method + ) + { + return -1; + } + + // Methods can have the same name, as long as the signature is unique + // A method that differs only in return type is not unique + public static void MethodSignatures( + ref int maxCount, // Pass by reference + out int count) + { + count = 15; // out param must be assigned before control leaves the method + } + + // GENERICS + // The classes for TKey and TValue is specified by the user calling this function. + // This method emulates the SetDefault of Python + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // You can narrow down the objects that are passed in + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // We can iterate, since T is a IEnumerable + foreach (var item in toPrint) + // Item is an int + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // OPTIONAL PARAMETERS + MethodSignatures(3, 1, 3, "Some", "Extra", "Strings"); + MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones + + // BY REF AND OUT PARAMETERS + int maxCount = 0, count; // ref params must have value + MethodSignatures(ref maxCount, out count); + + // EXTENSION METHODS + int i = 3; + i.Print(); // Defined below + + // NULLABLE TYPES - great for database interaction / return values + // any value type (i.e. not a class) can be made nullable by suffixing a ? + // <type>? <var name> = <value> + int? nullable = null; // short hand for Nullable<int> + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // true if not null + + // ?? is syntactic sugar for specifying default value (coalesce) + // in case variable is null + int notNullable = nullable ?? 0; // 0 + + // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is: + var magic = "magic is a string, at compile time, so you still get type safety"; + // magic = 9; will not work as magic is a string, not an int + + // GENERICS + // + var phonebook = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // Add some entries to the phone book + }; + + // Calling SETDEFAULT defined as a generic above + Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone + // nb, you don't need to specify the TKey and TValue since they can be + // derived implicitly + Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555 + + // LAMBDA EXPRESSIONS - allow you to write code in line + Func<int, int> square = (x) => x * x; // Last T item is the return value + Console.WriteLine(square(3)); // 9 + + // ERROR HANDLING - coping with an uncertain world + try + { + var funBike = PennyFarthing.CreateWithGears(6); + + // will no longer execute because CreateWithGears throws an exception + string some = ""; + if (true) some = null; + some.ToLower(); // throws a NullReferenceException + } + catch (NotSupportedException) + { + Console.WriteLine("Not so much fun now!"); + } + catch (Exception ex) // catch all other exceptions + { + throw new ApplicationException("It hit the fan", ex); + // throw; // A rethrow that preserves the callstack + } + // catch { } // catch-all without capturing the Exception + finally + { + // executes after try or catch + } + + // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily. + // Most of objects that access unmanaged resources (file handle, device contexts, etc.) + // implement the IDisposable interface. The using statement takes care of + // cleaning those IDisposable objects for you. + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("Nothing suspicious here"); + // At the end of scope, resources will be released. + // Even if an exception is thrown. + } + + // PARALLEL FRAMEWORK + // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // Will spin up separate threads for each request, and join on them + // before going to the next step! + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads + website => + { + // Do something that takes a long time on the file + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // This won't happen till after all requests have been completed + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // DYNAMIC OBJECTS (great for working with other languages) + dynamic student = new ExpandoObject(); + student.FirstName = "First Name"; // No need to define class first! + + // You can even add methods (returns a string, and takes in a string) + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of + // very useful Map / Filter / Reduce style methods + var bikes = new List<Bicycle>(); + bikes.Sort(); // Sorts the array + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels + var result = bikes + .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string> + + var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection + + // Create a list of IMPLICIT objects based on some parameters of the bike + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // Hard to show here, but you get type ahead completion since the compiler can implicitly work + // out the types above! + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + // ASPARALLEL + // And this is where things get wicked - combines linq and parallel operations + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // this will happen in parallel! Threads will automagically be spun up and the + // results divvied amongst them! Amazing for large datasets when you have lots of + // cores + + // LINQ - maps a store to IQueryable<T> objects, with delayed execution + // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document + var db = new BikeRepository(); + + // execution is delayed, which is great when querying a database + var filter = db.Bikes.Where(b => b.HasTassles); // no query run + if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality + filter = filter.Where(b => b.IsBroken); // no query run + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // still no query run + + // Now the query runs, but opens a reader, so only populates are you iterate through + foreach (string bike in query) + Console.WriteLine(result); + + + + } + + } // End LearnCSharp class + + // You can include other classes in a .cs file + + public static class Extensions + { + // EXTENSION FUNCTIONS + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + + // Class Declaration Syntax: + // <public/private/protected/internal> class <class name>{ + // //data fields, constructors, functions all inside. + // //functions are called as methods in Java. + // } + + public class Bicycle + { + // Bicycle's Fields/Variables + public int Cadence // Public: Can be accessed from anywhere + { + get // get - define a method to retrieve the property + { + return _cadence; + } + set // set - define a method to set a proprety + { + _cadence = value; // Value is the value passed in to the setter + } + } + private int _cadence; + + protected virtual int Gear // Protected: Accessible from the class and subclasses + { + get; // creates an auto property so you don't need a member field + set; + } + + internal int Wheels // Internal: Accessible from within the assembly + { + get; + private set; // You can set modifiers on the get/set methods + } + + int _speed; // Everything is private by default: Only accessible from within this class. + // can also use keyword private + public string Name { get; set; } + + // Enum is a value type that consists of a set of named constants + // It is really just mapping a name to a value (an int, unless specified otherwise). + // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong. + // An enum can't contain the same value twice. + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, //you can explicitly set a value to a name + Gitane // 43 + } + // We defined this type inside a Bicycle class, so it is a nested type + // Code outside of this class should reference this type as Bicycle.Brand + + public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type + + // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on + [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc + public enum BikeAccessories + { + None = 0, + Bell = 1, + MudGuards = 2, // need to set the values manually! + Racks = 4, + Lights = 8, + FullPackage = Bell | MudGuards | Racks | Lights + } + + // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell) + // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell + public BikeAccessories Accessories { get; set; } + + // Static members belong to the type itself rather then specific object. + // You can access them without a reference to any object: + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + public static int BicyclesCreated { get; set; } + + // readonly values are set at run time + // they can only be assigned upon declaration or in a constructor + readonly bool _hasCardsInSpokes = false; // read-only private + + // Constructors are a way of creating classes + // This is a default constructor + public Bicycle() + { + this.Gear = 1; // you can access members of the object with the keyword this + Cadence = 50; // but you don't always need it + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // This is a specified constructor (it contains arguments) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // calls base first + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // Constructors can be chained + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // Function Syntax: + // <public/private/protected> <return type> <function name>(<args>) + + // classes can implement getters and setters for their fields + // or they can implement properties (this is the preferred way in C#) + + // Method parameters can have default values. + // In this case, methods can be called with these parameters omitted + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // properties get/set values + // when only data needs to be accessed, consider using properties. + // properties may have either get or set, or both + private bool _hasTassles; // private variable + public bool HasTassles // public accessor + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // You can also define an automatic property in one line + // this syntax will create a backing field automatically. + // You can set an access modifier on either the getter or the setter (or both) + // to restrict its access: + public bool IsBroken { get; private set; } + + // Properties can be auto-implemented + public int FrameSize + { + get; + // you are able to specify access modifiers for either get or set + // this means only Bicycle class can call set on Framesize + private set; + } + + // It's also possible to define custom Indexers on objects. + // All though this is not entirely useful in this example, you + // could do bicycle[0] which yields "chris" to get the first passenger or + // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle) + private string[] passengers = { "chris", "phil", "darren", "regina" }; + + public string this[int i] + { + get { + return passengers[i]; + } + + set { + return passengers[i] = value; + } + } + + //Method to display the attribute values of this Object. + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Methods can also be static. It can be useful for helper methods + public static bool DidWeCreateEnoughBycles() + { + // Within a static method, we only can reference static class members + return BicyclesCreated > 9000; + } // If your class only needs static members, consider marking the class itself as static. + + + } // end class Bicycle + + // PennyFarthing is a subclass of Bicycle + class PennyFarthing : Bicycle + { + // (Penny Farthings are those bicycles with the big front wheel. + // They have no gears.) + + // calling parent constructor + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + throw new InvalidOperationException("You can't change gears on a PennyFarthing"); + } + } + + public static PennyFarthing CreateWithGears(int gears) + { + var penny = new PennyFarthing(1, 1); + penny.Gear = gears; // Oops, can't do this! + return penny; + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Calling the base version of the method + return result; + } + } + + // Interfaces only contain signatures of the members, without the implementation. + interface IJumpable + { + void Jump(int meters); // all interface members are implicitly public + } + + interface IBreakable + { + bool Broken { get; } // interfaces can contain properties as well as methods & events + } + + // Class can inherit only one other class, but can implement any amount of interfaces + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// Used to connect to DB for LinqToSql example. + /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional) + /// http://msdn.microsoft.com/en-us/data/jj193542.aspx + /// </summary> + public class BikeRepository : DbContext + { + public BikeRepository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // End Namespace +``` + +## Topics Not Covered + + * Attributes + * async/await, yield, pragma directives + * Web Development + * ASP.NET MVC & WebApi (new) + * ASP.NET Web Forms (old) + * WebMatrix (tool) + * Desktop Development + * Windows Presentation Foundation (WPF) (new) + * Winforms (old) + +## Further Reading + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx) diff --git a/css.html.markdown b/css.html.markdown new file mode 100644 index 00000000..811767e6 --- /dev/null +++ b/css.html.markdown @@ -0,0 +1,251 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + - ["Geoffrey Liu", "https://github.com/g-liu"] + - ["Connor Shea", "https://github.com/connorshea"] +filename: learncss.css +--- + +In the early days of the web there were no visual elements, just pure text. But with the +further development of browsers, fully visual web pages also became common. +CSS is the standard language that exists to keep the separation between +the content (HTML) and the look-and-feel of web pages. + +In short, what CSS does is to provide a syntax that enables you to target +different elements on an HTML page and assign different visual properties to them. + +Like any other languages, CSS has many versions. Here we focus on CSS2.0, +which is not the most recent version, but is the most widely supported and compatible version. + +**NOTE:** Because the outcome of CSS consists of visual effects, in order to +learn it, you need try everything in a +CSS playground like [dabblet](http://dabblet.com/). +The main focus of this article is on the syntax and some general tips. + + +```css +/* comments appear inside slash-asterisk, just like this line! + there are no "one-line comments"; this is the only comment style */ + +/* #################### + ## SELECTORS + #################### */ + +/* Generally, the primary statement in CSS is very simple */ +selector { property: value; /* more properties...*/ } + +/* the selector is used to target an element on page. + +You can target all elements on the page using asterisk! */ +* { color:red; } + +/* +Given an element like this on the page: + +<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' /> +*/ + +/* you can target it by its name */ +.some-class { } + +/* or by both classes! */ +.some-class.class2 { } + +/* or by its element name */ +div { } + +/* or its id */ +#someId { } + +/* or by the fact that it has an attribute! */ +[attr] { font-size:smaller; } + +/* or that the attribute has a specific value */ +[attr='value'] { font-size:smaller; } + +/* start with a value (CSS3) */ +[attr^='val'] { font-size:smaller; } + +/* or ends with (CSS3) */ +[attr$='ue'] { font-size:smaller; } + +/* or select by one of the values from the whitespace separated list (CSS3) */ +[otherAttr~='foo'] { font-size:smaller; } + +/* or value can be exactly “value” or can begin with “value” immediately followed by “-” (U+002D) */ +[otherAttr|='en'] { font-size:smaller; } + + +/* and more importantly you can combine these together -- there shouldn't be +any space between different parts because that makes it to have another +meaning. */ +div.some-class[attr$='ue'] { } + +/* you can also select an element based on its parent. */ + +/* an element which is direct child of an element (selected the same way) */ +div.some-parent > .class-name {} + +/* or any of its parents in the tree + the following basically means any element that has class "class-name" + and is child of a div with class name "some-parent" IN ANY DEPTH */ +div.some-parent .class-name {} + +/* warning: the same selector without space has another meaning. + can you say what? */ +div.some-parent.class-name {} + +/* you also might choose to select an element based on its direct + previous sibling */ +.i-am-before + .this-element { } + +/* or any sibling before this */ +.i-am-any-before ~ .this-element {} + +/* There are some pseudo classes that allows you to select an element + based on its page behaviour (rather than page structure) */ + +/* for example for when an element is hovered */ +selector:hover {} + +/* or a visited link */ +selected:visited {} + +/* or not visited link */ +selected:link {} + +/* or an input element which is focused */ +selected:focus {} + + +/* #################### + ## PROPERTIES + #################### */ + +selector { + + /* Units */ + width: 50%; /* in percent */ + font-size: 2em; /* times current font-size */ + width: 200px; /* in pixels */ + font-size: 20pt; /* in points */ + width: 5cm; /* in centimeters */ + min-width: 50mm; /* in millimeters */ + max-width: 5in; /* in inches. max-(width|height) */ + height: 0.2vh; /* times vertical height of browser viewport (CSS3) */ + width: 0.4vw; /* times horizontal width of browser viewport (CSS3) */ + min-height: 0.1vmin; /* the lesser of vertical, horizontal dimensions of browser viewport (CSS3) */ + max-width: 0.3vmax; /* same as above, except the greater of the dimensions (CSS3) */ + + /* Colors */ + background-color: #F6E; /* in short hex */ + background-color: #F262E2; /* in long hex format */ + background-color: tomato; /* can be a named color */ + background-color: rgb(255, 255, 255); /* in rgb */ + background-color: rgb(10%, 20%, 50%); /* in rgb percent */ + background-color: rgba(255, 0, 0, 0.3); /* in semi-transparent rgb (CSS3) */ + background-color: transparent; /* see thru */ + background-color: hsl(0, 100%, 50%); /* hsl format (CSS3). */ + background-color: hsla(0, 100%, 50%, 0.3); /* Similar to RGBA, specify opacity at end (CSS3) */ + + + /* Images */ + background-image: url(/path-to-image/image.jpg); /* quotes inside url() optional */ + + /* Fonts */ + font-family: Arial; + font-family: "Courier New"; /* if name has space it appears in single or double quotes */ + font-family: "Courier New", Trebuchet, Arial, sans-serif; /* if first one was not found + browser uses the second font, and so forth */ +} + +``` + +## Usage + +Save any CSS you want in a file with extension `.css`. + +```xml +<!-- you need to include the css file in your page's <head>: --> +<link rel='stylesheet' type='text/css' href='path/to/style.css' /> + +<!-- you can also include some CSS inline in your markup. However it is highly +recommended to avoid this. --> +<style> + a { color: purple; } +</style> + +<!-- or directly set CSS properties on the element. +This has to be avoided as much as you can. --> +<div style="border: 1px solid red;"> +</div> + +``` + +## Precedence + +As you noticed an element may be targetted by more than one selector. +and may have a property set on it in more than one. +In these cases, one of the rules takes precedence over others. + +Given the following CSS: + +```css +/*A*/ +p.class1[attr='value'] + +/*B*/ +p.class1 {} + +/*C*/ +p.class2 {} + +/*D*/ +p {} + +/*E*/ +p { property: value !important; } + +``` + +and the following markup: + +```xml +<p style='/*F*/ property:value;' class='class1 class2' attr='value'> +</p> +``` + +The precedence of style is as followed: +Remember, the precedence is for each **property**, not for the entire block. + +* `E` has the highest precedence because of the keyword `!important`. + It is recommended to avoid this unless it is strictly necessary to use. +* `F` is next, because it is inline style. +* `A` is next, because it is more "specific" than anything else. + more specific = more specifiers. here 3 specifiers: 1 tagname `p` + + class name `class1` + 1 attribute `attr='value'` +* `C` is next. although it has the same specificness as `B` + but it appears last. +* Then is `B` +* and lastly is `D`. + +## Compatibility + +Most of the features in CSS2 (and gradually in CSS3) are compatible across +all browsers and devices. But it's always vital to have in mind the compatibility +of what you use in CSS with your target browsers. + +[QuirksMode CSS](http://www.quirksmode.org/css/) is one of the best sources for this. + +To run a quick compatibility check, [Can I Use...](http://caniuse.com) is a great resource. + +## Further Reading + +* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) +* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) +* [SCSS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing diff --git a/d.html.markdown b/d.html.markdown new file mode 100644 index 00000000..ba24b60f --- /dev/null +++ b/d.html.markdown @@ -0,0 +1,247 @@ +--- +language: D +filename: learnd.d +contributors: + - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"] +lang: en +--- + +```c +// You know what's coming... +module hello; + +import std.stdio; + +// args is optional +void main(string[] args) { + writeln("Hello, World!"); +} +``` + +If you're like me and spend way too much time on the internet, odds are you've heard +about [D](http://dlang.org/). The D programming language is a modern, general-purpose, +multi-paradigm language with support for everything from low-level features to +expressive high-level abstractions. + +D is actively developed by Walter Bright and Andrei Alexandrescu, two super smart, really cool +dudes. With all that out of the way, let's look at some examples! + +```c +import std.stdio; + +void main() { + + // Conditionals and loops work as expected. + for(int i = 0; i < 10000; i++) { + writeln(i); + } + + auto n = 1; // use auto for type inferred variables + + // Numeric literals can use _ as a digit seperator for clarity + while(n < 10_000) { + n += n; + } + + do { + n -= (n / 2); + } while(n > 0); + + // For and while are nice, but in D-land we prefer foreach + // The .. creates a continuous range, excluding the end + foreach(i; 1..1_000_000) { + if(n % 2 == 0) + writeln(i); + } + + foreach_reverse(i; 1..int.max) { + if(n % 2 == 1) { + writeln(i); + } else { + writeln("No!"); + } + } +} +``` + +We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions +are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore, +we can use templates to parameterize all of these on both types and values! + +```c +// Here, T is a type parameter. Think <T> from C++/C#/Java +struct LinkedList(T) { + T data = null; + LinkedList!(T)* next; // The ! is used to instaniate a parameterized type. Again, think <T> +} + +class BinTree(T) { + T data = null; + + // If there is only one template parameter, we can omit parens + BinTree!T left; + BinTree!T right; +} + +enum Day { + Sunday, + Monday, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, +} + +// Use alias to create abbreviations for types + +alias IntList = LinkedList!int; +alias NumTree = BinTree!double; + +// We can create function templates as well! + +T max(T)(T a, T b) { + if(a < b) + return b; + + return a; +} + +// Use the ref keyword to ensure pass by referece. +// That is, even if a and b are value types, they +// will always be passed by reference to swap +void swap(T)(ref T a, ref T b) { + auto temp = a; + + a = b; + b = temp; +} + +// With templates, we can also parameterize on values, not just types +class Matrix(uint m, uint n, T = int) { + T[m] rows; + T[n] columns; +} + +auto mat = new Matrix!(3, 3); // We've defaulted type T to int + +``` + +Speaking of classes, let's talk about properties for a second. A property +is roughly a function that may act like an lvalue, so we can +have the syntax of POD structures (`structure.x = 7`) with the semantics of +getter and setter methods (`object.setX(7)`)! + +```c +// Consider a class parameterized on a types T, U + +class MyClass(T, U) { + T _data; + U _other; + +} + +// And "getter" and "setter" methods like so +class MyClass(T, U) { + T _data; + U _other; + + // Constructors are always named `this` + this(T t, U u) { + data = t; + other = u; + } + + // getters + @property T data() { + return _data; + } + + @property U other() { + return _other; + } + + // setters + @property void data(T t) { + _data = t; + } + + @property void other(U u) { + _other = u; + } +} +// And we use them in this manner + +void main() { + auto mc = MyClass!(int, string); + + mc.data = 7; + mc.other = "seven"; + + writeln(mc.data); + writeln(mc.other); +} +``` + +With properties, we can add any amount of logic to +our getter and setter methods, and keep the clean syntax of +accessing members directly! + +Other object-oriented goodies at our disposal +include `interface`s, `abstract class`es, +and `override`ing methods. D does inheritance just like Java: +Extend one class, implement as many interfaces as you please. + +We've seen D's OOP facilities, but let's switch gears. D offers +functional programming with first-class functions, `pure` +functions, and immutable data. In addition, all of your favorite +functional algorithms (map, filter, reduce and friends) can be +found in the wonderful `std.algorithm` module! + +```c +import std.algorithm : map, filter, reduce; +import std.range : iota; // builds an end-exclusive range + +void main() { + // We want to print the sum of a list of squares of even ints + // from 1 to 100. Easy! + + // Just pass lambda expressions as template parameters! + // You can pass any old function you like, but lambdas are convenient here. + auto num = iota(1, 101).filter!(x => x % 2 == 0) + .map!(y => y ^^ 2) + .reduce!((a, b) => a + b); + + writeln(num); +} +``` + +Notice how we got to build a nice Haskellian pipeline to compute num? +That's thanks to a D innovation know as Uniform Function Call Syntax. +With UFCS, we can choose whether to write a function call as a method +or free function call! Walter wrote a nice article on this +[here.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) +In short, you can call functions whose first parameter +is of some type A on any expression of type A as a method. + +I like parallelism. Anyone else like parallelism? Sure you do. Let's do some! + +```c +import std.stdio; +import std.parallelism : parallel; +import std.math : sqrt; + +void main() { + // We want take the square root every number in our array, + // and take advantage of as many cores as we have available. + auto arr = new double[1_000_000]; + + // Use an index, and an array element by referece, + // and just call parallel on the array! + foreach(i, ref elem; parallel(arr)) { + ref = sqrt(i + 1.0); + } +} + + +``` diff --git a/dart.html.markdown b/dart.html.markdown index 34d1c6a8..f7601271 100644 --- a/dart.html.markdown +++ b/dart.html.markdown @@ -81,7 +81,7 @@ example5() { // Where classBody can include instance methods and variables, but also // class methods and variables. class Example6Class { - var example6InstanceVariable = "Example6 instance variable"; + var example6InstanceVariable = "Example6 instance variable"; sayIt() { print(example6InstanceVariable); } @@ -92,7 +92,7 @@ example6() { // Class methods and variables are declared with "static" terms. class Example7Class { - static var example7ClassVariable = "Example7 class variable"; + static var example7ClassVariable = "Example7 class variable"; static sayItFromClass() { print(example7ClassVariable); } @@ -111,7 +111,7 @@ example7() { // by default. But arrays and maps are not. They can be made constant by // declaring them "const". var example8A = const ["Example8 const array"], - example8M = const {"someKey": "Example8 const map"}; + example8M = const {"someKey": "Example8 const map"}; example8() { print(example8A[0]); print(example8M["someKey"]); @@ -245,7 +245,7 @@ example18() { // Strings with triple single-quotes or triple double-quotes span // multiple lines and include line delimiters. example19() { - print('''Example19 <a href="etc"> + print('''Example19 <a href="etc"> Example19 Don't can't I'm Etc Example19 </a>'''); } @@ -272,7 +272,7 @@ example20() { class Example21 { List<String> _names; Example21() { - _names = ["a", "b"]; + _names = ["a", "b"]; } List<String> get names => _names; set names(List<String> list) { diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown new file mode 100644 index 00000000..fb9cd9d4 --- /dev/null +++ b/de-de/bash-de.html.markdown @@ -0,0 +1,92 @@ +--- +category: tool +tool: bash +lang: de-de +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] +translators: + - ["kultprok", "http://www.kulturproktologie.de"] +filename: LearnBash-de.sh +--- + +Bash ist der Name der Unix-Shell, die als Shell des GNU-Betriebssystems und auch als Standard-Shell von Linux und Mac OS X ausgeliefert wurde. +Beinahe alle der folgenden Beispiele können als Teile eines Shell-Skripts oder direkt in der Shell ausgeführt werden. + +[Weitere Informationen \(Englisch\)](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Die erste Zeile des Scripts nennt sich Shebang, dies gibt dem System an, +# wie das Script ausgeführt werden soll: http://de.wikipedia.org/wiki/Shebang +# Du hast es bestimmt schon mitgekriegt, Kommentare fangen mit # an. Das Shebang ist auch ein Kommentar + +# Ein einfaches Beispiel mit hello world: +echo Hello, world! + +# Jeder Befehl fängt auf einer neuen Zeile oder nach einem Semikolon an: +echo 'Dies ist die erste Zeile'; echo 'Dies die zweite Zeile' + +# Variablen deklariert man so: +VARIABLE="irgendein String" + +# Aber nicht so: +VARIABLE = "irgendein String" +# Bash wird VARIABLE für einen Befehl halten, den es ausführen soll. Es wird einen Fehler ausgeben, +# weil es den Befehl nicht findet. + +# Eine Variable wird so benutzt: +echo $VARIABLE +echo "$VARIABLE" +# Wenn du eine Variable selbst benutzt – ihr Werte zuweist, sie exportierst oder irgendetwas anders –, +# dann über ihren Namen ohne $. Aber wenn du ihren zugewiesenen Wert willst, dann musst du $ voranstellen. + +# Einen Wert aus der Eingabe lesen: +echo "Wie heisst du?" +read NAME # Wir mussten nicht mal eine neue Variable deklarieren +echo Hello, $NAME! + +# Wir haben die übliche if-Struktur: +if true +then + echo "Wie erwartet" +else + echo "Und dies nicht" +fi + +# Ausdrücke werden im folgenden Format festgehalten: +echo $(( 10 + 5 )) + +# Anders als andere Programmiersprachen ist Bash eine Shell – es arbeitet also im Kontext von Verzeichnissen. +# Du kannst alle Dateien und Verzeichnisse im aktiven Verzeichnis mit ls auflisten: +ls + +# Diese Befehle haben Optionen, die ihre Ausführung beeinflussen: +ls -l # Liste alle Dateien und Unterverzeichnisse auf einer eigenen Zeile auf + +# Ergebnisse eines vorangegangenen Befehls können an den nächsten Befehl als Input übergeben werden. +# Der grep-Befehl filtert den Input nach dem vorgegebenen Muster. So können wir alle +# txt-Dateien im aktuellen Verzeichnis auflisten: +ls -l | grep "\.txt" + +# Befehle können innerhalb anderer Befehle mit $( ) erstetzt werden: +# Der folgende Befehl zeigt die Anzahl aller Dateien und Unterverzeichnisse +# im aktuellen Verzeichnis an. +echo "Dieser Ordner beinhaltet $(ls | wc -l) Dateien und Verzeichnisse." + +# Bash nutzt einen case-Ausdruck, der sich ähnlich wie switch in Java oder C++ verhält. +case "$VARIABLE" +in + # Liste der Fälle, die unterschieden werden sollen + 0) echo "Hier ist eine Null." + 1) echo "Hier ist eine Eins." + *) echo "Das ist nicht Null." +esac + +# loops iterieren über die angegebene Zahl von Argumenten: +# Der Inhalt von $VARIABLE wird dreimal ausgedruckt. +for $VARIABLE in x y z +do + echo "$VARIABLE" +done +``` diff --git a/de-de/coffeescript-de.html.markdown b/de-de/coffeescript-de.html.markdown new file mode 100644 index 00000000..98a452ba --- /dev/null +++ b/de-de/coffeescript-de.html.markdown @@ -0,0 +1,106 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Frederik Ring", "https://github.com/m90"] + - ["Philipp Fischbeck", "https://github.com/PFischbeck"] +filename: coffeescript-de.coffee +lang: de-de +--- + +CoffeeScript ist eine kleine Sprache, die eins zu eins nach JavaScript übersetzt wird - es findet keine Interpretation zur Laufzeit statt. +Als Nachfolger von JavaScript konzipiert, gibt CoffeeScript sein Bestes, lesbaren, gut formatierten und sauber laufenden JavaScript-Code zu erzeugen, der in jeder JavaScript-Laufzeit einwandfrei funktioniert. + +Auf [der CoffeeScript Website](http://coffeescript.org/) gibt es ein ausführliches Tutorial. + +``` coffeescript +# CoffeeScript ist eine dieser Sprachen für "Hipster" +# und folgt daher vielen Trends und Einflüssen aus modernen Sprachen. +# Kommentare werden daher wie in Ruby und Python mit Hashes gekennzeichnet + +### +Kommentarblöcke sehen aus wie diese und werden direkt nach '/ *'s und '* /'s +im erzeugten JavaScript umgewandelt. + +Vorweg: bevor du mit CoffeeScript anfängst, solltest du bereits einen guten +Überblick über die Sprache JavaScript haben. +### + +# Zuweisung: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# Bedingungen: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# Funktionen: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +fill = (container, liquid = "Kaffee") -> + "#{container} wird mit #{liquid} gefüllt..." +#=>var fill; +# +#fill = function(container, liquid) { +# if (liquid == null) { +# liquid = "Kaffee"; +# } +# return container + " wird mit " + liquid + " gefüllt..."; +#}; + +# "Ranges": +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# Objekte: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# "Splats": +race = (winner, runners...) -> + print winner, runners +#=>race = function() { +# var runners, winner; +# winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(winner, runners); +#}; + +# Existenz-Operator: +alert "Hab ich's nicht gesagt?" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Hab ich's nicht gesagt?"); } + +# Listen-Abstraktion: +cubes = (math.cube num for num in list) +#=>cubes = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +foods = ['Brokkoli', 'Spinat', 'Schokolade'] +eat food for food in foods when food isnt 'Schokolade' +#=>foods = ['Brokkoli', 'Spinat', 'Schokolade']; +# +#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) { +# food = foods[_k]; +# if (food !== 'Schokolade') { +# eat(food); +# } +#} +``` + +## Weiterführende Links + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown new file mode 100644 index 00000000..8ad7d71f --- /dev/null +++ b/de-de/csharp-de.html.markdown @@ -0,0 +1,890 @@ +---
+language: c#
+contributors:
+ - ["Irfan Charania", "https://github.com/irfancharania"]
+ - ["Max Yankov", "https://github.com/golergka"]
+ - ["Melvyn Laïly", "http://x2a.yt"]
+ - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+ - ["Frederik Ring", "https://github.com/m90"]
+filename: LearnCSharp-de.cs
+lang: de-de
+---
+C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.
+
+[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Einzeilige Kommentare starten mit zwei Schrägstrichen: //
+/*
+Mehrzeile Kommentare wie in C Schrägstrich / Stern
+*/
+/// <summary>
+/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden
+/// </summary>
+
+// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// definiert einen Namespace um Code in "packages" zu organisieren
+namespace Learning
+{
+ // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei
+ // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu
+ // handhaben führt aber unweigerlich ins Chaos (wirklich)!
+ public class LearnCSharp
+ {
+ // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,
+ // wenn du bereits Java oder C++ programmieren kannst:
+ // lies bei "Interessante Features" weiter!
+ public static void Syntax()
+ {
+ // Mit Console.WriteLine kannst du einfachen Text ausgeben:
+ Console.WriteLine("Hallo Welt");
+ Console.WriteLine(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Console.Write erzeugt keinen Zeilenumbruch
+ Console.Write("Hallo ");
+ Console.Write("Welt");
+
+ ///////////////////////////////////////////////////
+ // Typen & Variablen
+ ///////////////////////////////////////////////////
+
+ // Deklariere eine Variable mit <Typ> <Name>
+
+ // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl
+ // (-128 <= sbyte <= 127)
+ sbyte fooSbyte = 100;
+
+ // Byte - Vorzeichenlose 8-Bit Ganzzahl
+ // (0 <= byte <= 255)
+ byte fooByte = 100;
+
+ // Short - 16-Bit Ganzzahl
+ // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)
+ // Vorzeichenlos - (0 <= ushort <= 65,535)
+ short fooShort = 10000;
+ ushort fooUshort = 10000;
+
+ // Integer - 32-bit Ganzzahl
+ int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+ uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+ // Long - 64-bit Ganzzahl
+ long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+ // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder
+ // uint behandelt. Ein nachgestelltes L markiert den Wert als long
+ // oder ulong.
+
+ // Double - Double-precision 64-bit IEEE 754 Fließkommazahl
+ double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen
+
+ // Float - Single-precision 32-bit IEEE 754 Fließkommazahl
+ float fooFloat = 234.5f; // Genauigkeit: 7 Stellen
+ // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ
+ // float handelt
+
+ // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als
+ // andere Fließkommatypen, und somit bestens geeignet für
+ // die Berechnung von Geld- und Finanzwerten
+ decimal fooDecimal = 150.3m;
+
+ // Boolean - true & false
+ bool fooBoolean = true; // oder false
+
+ // Char - Ein einzelnes 16-Bit Unicode Zeichen
+ char fooChar = 'A';
+
+ // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die
+ // alle Werttypen sind, ist String ein Referenztyp. Strings sind
+ // somit nullable, Werttypen sind dies nicht.
+ string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";
+ Console.WriteLine(fooString);
+
+ // Jeder Buchstabe eines Strings kann über seinen Index
+ // referenziert werden:
+ char charFromString = fooString[1]; // => 'e'
+ // Strings sind unveränderlich:
+ // `fooString[1] = 'X';` funktioniert nicht
+
+ // Ein Vergleich zweier Strings, unter Berücksichtigung der
+ // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c
+ // in deutschsprachigen Umgebungen), und ohne Beachtung von
+ // Groß- und Kleinschreibung:
+ string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+ // Formatierung, genau wie "sprintf"
+ string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+ // Datumsangaben und Formatierung
+ DateTime fooDate = DateTime.Now;
+ Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+ // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String
+ // schreiben. Um " zu maskieren benutzt man ""
+ string bazString = @"Hier geht es
+zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
+
+ // Die Keywords const oder readonly kennzeichnen eine
+ // unveränderliche Variable/Konstante. Die Werte von Konstanten
+ // werden übrigens bereits zur Compile-Zeit berechnet.
+ const int HOURS_I_WORK_PER_WEEK = 9001;
+
+ ///////////////////////////////////////////////////
+ // Datenstrukturen
+ ///////////////////////////////////////////////////
+
+ // Arrays - Index beginnt bei Null
+ // Die Größe des Arrays wird bei der Deklaration festgelegt.
+ // Die syntaktische Struktur um ein neues Array zu erzeugen sieht
+ // folgendermaßen aus:
+ // <datatype>[] <varname> = new <datatype>[<array size>];
+ int[] intArray = new int[10];
+
+ // Arrays können auch über ein Array-Literal deklariert werden:
+ int[] y = { 9000, 1000, 1337 };
+
+ // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element
+ Console.WriteLine("intArray @ 0: " + intArray[0]);
+ // Arrays sind veränderbar
+ intArray[1] = 1;
+
+ // Listen
+ // Durch ihre größere Flexibilität kommen Listen in C# weit
+ // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:
+ // List<datatype> <varname> = new List<datatype>();
+ List<int> intList = new List<int>();
+ List<string> stringList = new List<string>();
+ List<int> z = new List<int> { 9000, 1000, 1337 };
+ // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"
+
+ // Listen haben keinen Default-Wert.
+ // Bevor auf einen Index zugegriffen werden kann, muss dieser
+ // auch gesetzt worden sein:
+ intList.Add(1);
+ Console.WriteLine("intList @ 0: " + intList[0]);
+
+ // Andere interessante Datenstrukturen sind:
+ // Stack/Queue
+ // Dictionary (entspricht einer Hash Map)
+ // HashSet
+ // Read-only Collections
+ // Tuple (.Net 4+)
+
+ ///////////////////////////////////////
+ // Operatoren
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Operatoren");
+
+ // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:
+ // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)
+ int i1 = 1, i2 = 2;
+
+ // Arithmetik funktioniert wie erwartet:
+ Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+ // Modulo
+ Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+ // Vergleiche
+ Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+ Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+ Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+ Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+ Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+ Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+ // Bitweise Operatoren
+ /*
+ ~ Unäres bitweises NICHT
+ << Verschieben nach links
+ >> Verschieben nach rechts
+ & Bitweises UND
+ ^ Bitweises exklusives ODER
+ | Bitweises inklusives ODER
+ */
+
+ // Inkremente
+ int i = 0;
+ Console.WriteLine("\n->Inkrement / Dekrement");
+ Console.WriteLine(i++); //i = 1. Post-Inkrement
+ Console.WriteLine(++i); //i = 2. Pre-Inkrement
+ Console.WriteLine(i--); //i = 1. Post-Dekrement
+ Console.WriteLine(--i); //i = 0. Pre-Dekrement
+
+ ///////////////////////////////////////
+ // Kontrollstrukturen
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Kontrollstrukturen");
+
+ // If-Statements funktionieren wie in C
+ int j = 10;
+ if (j == 10)
+ {
+ Console.WriteLine("Ich werde ausgegeben");
+ }
+ else if (j > 10)
+ {
+ Console.WriteLine("Ich nicht");
+ }
+ else
+ {
+ Console.WriteLine("Ich leider auch nicht");
+ }
+
+ // Ternärer Operator
+ // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:
+ // <condition> ? <true> : <false>
+ int zumVergleich = 17;
+ string isTrue = zumVergleich == 17 ? "Ja" : "Nein";
+
+ // while-Schleife
+ int fooWhile = 0;
+ while (fooWhile < 100)
+ {
+ // Wird 100mal wiederholt, fooWhile 0->99
+ fooWhile++;
+ }
+
+ // do-while-Schleife
+ int fooDoWhile = 0;
+ do
+ {
+ // Wird 100mal wiederholt, fooDoWhile 0->99
+ fooDoWhile++;
+ } while (fooDoWhile < 100);
+
+ //for-Schleifen => for(<start_statement>; <conditional>; <step>)
+ for (int fooFor = 0; fooFor < 10; fooFor++)
+ {
+ // Wird 10mal wiederholt, fooFor 0->9
+ }
+
+ // foreach-Schleife
+ // Die normale Syntax für eine foreach-Schleife lautet:
+ // foreach(<iteratorType> <iteratorName> in <enumerable>)
+ // foreach kann mit jedem Objekt verwendet werden das IEnumerable
+ // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen
+ // (Array, List, Dictionary...) im .NET Framework implementieren
+ // eines dieser beiden Interfaces.
+
+ foreach (char character in "Hallo Welt".ToCharArray())
+ {
+ // Ein Durchgang für jedes Zeichen im String
+ }
+ // (ToCharArray() könnte man hier übrigens auch weglassen,
+ // da String IEnumerable bereits implementiert)
+
+ // Switch Struktur
+ // Ein Switch funktioniert mit byte, short, char und int Datentypen.
+ // Auch Aufzählungstypen können verwendet werden, genau wie
+ // die Klasse String, und ein paar Sonderklassen, die Wrapper für
+ // Primitives sind: Character, Byte, Short und Integer
+ int month = 3;
+ string monthString;
+ switch (month)
+ {
+ case 1:
+ monthString = "Januar";
+ break;
+ case 2:
+ monthString = "Februar";
+ break;
+ case 3:
+ monthString = "März";
+ break;
+ // Man kann für mehrere Fälle auch das selbe Verhalten
+ // definieren. Jeder Block muss aber mit einem break-Statement
+ // abgeschlossen werden. Einzelne Fälle können über
+ // `goto case x` erreicht werden
+ case 6:
+ case 7:
+ case 8:
+ monthString = "Sommer!!";
+ break;
+ default:
+ monthString = "Irgendein anderer Monat";
+ break;
+ }
+
+ ///////////////////////////////////////
+ // Umwandlung von Datentypen und Typecasting
+ ///////////////////////////////////////
+
+ // Umwandlung
+
+ // von String nach Integer
+ // bei einem Fehler wirft diese Code eine Exception
+ int.Parse("123"); //gibt die Ganzzahl 123 zurück
+
+ // TryParse gibt bei einem Fehler den Default-Wert zurück
+ // (im Fall von int: 0)
+ int tryInt;
+ if (int.TryParse("123", out tryInt)) // gibt true oder false zurück
+ {
+ Console.WriteLine(tryInt); // 123
+ }
+
+ // von Integer nach String
+ // Die Klasse Convert stellt Methoden zur Konvertierung von
+ // unterschiedlichsten Daten zur Verfügung:
+ Convert.ToString(123); // "123"
+ // oder
+ tryInt.ToString(); // "123"
+ }
+
+ ///////////////////////////////////////
+ // Klassen
+ ///////////////////////////////////////
+ public static void Classes()
+ {
+
+ // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen
+ Bicycle trek = new Bicycle();
+
+ // So werden Methoden der Instanz aufgerufen
+ trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen
+ trek.Cadence = 100;
+
+ // ToString ist eine Konvention über die man üblicherweiser
+ // Informationen über eine Instanz erhält
+ Console.WriteLine("Infos zu trek: " + trek.ToString());
+
+ // Wir instantiieren ein neues Hochrad
+ PennyFarthing funbike = new PennyFarthing(1, 10);
+ Console.WriteLine("Infos zu funbike: " + funbike.ToString());
+
+ Console.Read();
+ } // Ende der Methode main
+
+ // Main als Konsolenstartpunkt
+ // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen
+ public static void Main(string[] args)
+ {
+ OtherInterestingFeatures();
+ }
+
+ ///////////////////////////////////////
+ // Interessante Features
+ ///////////////////////////////////////
+
+ // Methodensignaturen
+
+ public // Sichtbarkeit
+ static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)
+ int // Typ des Rückgabewerts,
+ MethodSignatures(
+ // Erstes Argument, erwartet int
+ int maxCount,
+ // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird
+ int count = 0,
+ int another = 3,
+ // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)
+ params string[] otherParams
+ )
+ {
+ return -1;
+ }
+
+ // Methoden können überladen werden, solange sie eindeutige
+ // Signaturen haben
+ public static void MethodSignatures(string maxCount)
+ {
+ }
+
+ // Generische Typen
+ // Die Typen für TKey und TValue werden erst beim Aufruf der Methode
+ // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python:
+ public static TValue SetDefault<TKey, TValue>(
+ IDictionary<TKey, TValue> dictionary,
+ TKey key,
+ TValue defaultItem)
+ {
+ TValue result;
+ if (!dictionary.TryGetValue(key, out result))
+ {
+ return dictionary[key] = defaultItem;
+ }
+ return result;
+ }
+
+ // Möglichen Typen lassen sich auch über ihr Interface beschränken:
+ public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+ {
+ // Da T ein IEnumerable ist können wir foreach benutzen
+ foreach (var item in toPrint)
+ {
+ // Item ist ein int
+ Console.WriteLine(item.ToString());
+ }
+ }
+
+ public static void OtherInterestingFeatures()
+ {
+ // Optionale Parameter
+ MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");
+ // setzt explizit einen bestimmten Parameter, andere werden übersprungen
+ MethodSignatures(3, another: 3);
+
+ // Erweiterungsmethoden
+ int i = 3;
+ i.Print(); // Weiter unten definiert
+
+ // Nullables - perfekt für die Interaktion mit
+ // Datenbanken / Rückgabewerten
+ // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?
+ // nullable gemacht werden: <type>? <varname> = <value>
+ int? nullable = null; // Die explizite Langform wäre Nullable<int>
+ Console.WriteLine("Mein Nullable: " + nullable);
+ bool hasValue = nullable.HasValue; // true wenn nicht null
+
+ // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall
+ // dass die Variable null ist festzulegen.
+ int notNullable = nullable ?? 0; // 0
+
+ // Implizit typisierte Variablen
+ // Man kann auch den Typ einer Variable auch vom Compiler
+ // bestimmen lassen:
+ var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";
+ magic = 9; // funktioniert nicht da magic vom Typ String ist
+
+ // Generics
+ var phonebook = new Dictionary<string, string>() {
+ {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu
+ };
+
+ // Hier könnte man auch unser generisches SetDefault von
+ // weiter oben benutzen:
+ Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon
+ // TKey und TValue müssen nicht zwingend angegeben werden, da sie
+ // auch implizit vom Compiler ermittelt werden können
+ Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67
+
+ // Lambdas - konzise Syntax für Inline-Funktionen
+ Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert
+ Console.WriteLine(square(3)); // 9
+
+ // Disposables - einfaches Management von nicht verwalteten Ressourcen
+ // So gut wie alle Objekte die auf nicht verwaltete Ressourcen
+ // (Dateien, Geräte, ...) zugreifen, implementieren das Interface
+ // IDisposable. Das using Statement stellt sicher dass die vom
+ // IDisposable benutzten Ressourcen nach der Benutzung wieder
+ // freigegeben werden:
+ using (StreamWriter writer = new StreamWriter("log.txt"))
+ {
+ writer.WriteLine("Alles bestens!");
+ // Am Ende des Codeblocks werden die Ressourcen wieder
+ // freigegeben - auch im Falle einer Exception
+ }
+
+ // Parallel Klasse
+ // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+ var websites = new string[] {
+ "http://www.google.com", "http://www.reddit.com",
+ "http://www.shaunmccarthy.com"
+ };
+ var responses = new Dictionary<string, string>();
+
+ // Für jeden Request wird ein neuer Thread erzeugt, der nächste
+ // Schritt wird erst nach Beendigung aller Tasks ausgeführt
+ Parallel.ForEach(websites,
+ // maximal 3 Threads gleichzeitig
+ new ParallelOptions() {MaxDegreeOfParallelism = 3},
+ website =>
+ {
+ // Hier folgt eine langwierige, asynchrone Operation
+ using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+ {
+ responses[website] = r.ContentType;
+ }
+ });
+
+ // Dieser Code wird erst nach Beendigung aller Requests ausgeführt
+ foreach (var key in responses.Keys)
+ {
+ Console.WriteLine("{0}:{1}", key, responses[key]);
+ }
+
+ // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)
+ dynamic student = new ExpandoObject();
+ // hier muss keine Typ angegeben werden
+ student.FirstName = "Christian";
+
+ // Einem solchen Objekt kann man sogar Methoden zuordnen.
+ // Das Beispiel gibt einen String zurück und erwartet einen String
+ student.Introduce = new Func<string, string>(
+ (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));
+ Console.WriteLine(student.Introduce("Bettina"));
+
+ // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren
+ // dieses Interface, welches eine Vielzahl von funktionalen Methoden
+ // wie Map / Filter / Reduce zur Verfügung stellt:
+ var bikes = new List<Bicycle>();
+ // sortiert die Liste
+ bikes.Sort();
+ // sortiert nach Anzahl Räder
+ bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));
+ var result = bikes
+ // diese Filter können auch aneinandergehängt werden
+ .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)
+ .Where(b => b.IsBroken && b.HasTassles)
+ // diese Zuordnung gibt ein IQueryable<String> zurück
+ .Select(b => b.ToString());
+
+ // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert
+ var sum = bikes.Sum(b => b.Wheels);
+
+ // So erzeugt man ein implizit typisiertes Objekt, basierend auf
+ // den Parametern der Elemente:
+ var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+ // Auch wenn wir es hier nicht demonstrieren können:
+ // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,
+ // da der Compiler in der Lage ist, die passenden Typen zu erkennen.
+ foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+ {
+ Console.WriteLine(bikeSummary.Name);
+ }
+
+ // AsParallel-Methode
+ // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert
+ // LINQ und parallele Operationen:
+ var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+ // Diese Berechnung passiert parallel! Benötigte Threads werden
+ // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.
+ // Ein Traum für die Verarbeitung von großen Datenmengen
+ // auf mehreren Cores!
+
+ // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab
+ // LinqToSql beispielsweise speichert und liest aus einer
+ // SQL-Datenbank, LinqToXml aus einem XML-Dokument.
+ // LINQ-Operationen werden "lazy" ausgeführt.
+ var db = new BikeRepository();
+
+ // Die verzögerte Ausführung ist optimal für Datenbankabfragen
+ var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage
+ // Es können noch mehr Filter hinzugefügt werden (auch mit
+ // Bedingungen) - ideal für z.B. "erweiterte Suchen"
+ if (42 > 6)
+ {
+ filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage
+ }
+
+ var query = filter
+ .OrderBy(b => b.Wheels)
+ .ThenBy(b => b.Name)
+ .Select(b => b.Name); // auch hier: immer noch keine Abfrage
+
+ // Erst hier wird die Datenbankabfrage wirklich ausgeführt,
+ // limitiert auf die Elemente die der foreach-Loop verwendet
+ foreach (string bike in query)
+ {
+ Console.WriteLine(result);
+ }
+
+ }
+
+ } // Ende der Klasse LearnCSharp
+
+ // Eine .cs-Datei kann auch mehrere Klassen enthalten
+
+ public static class Extensions
+ {
+ // Erweiterungsmethoden
+ public static void Print(this object obj)
+ {
+ Console.WriteLine(obj.ToString());
+ }
+ }
+
+ // Syntax zur Deklaration einer Klasse:
+ // <public/private/protected/internal> class <class name>{
+ // // Datenfelder, Konstruktoren und Methoden leben alle
+ // // innerhalb dieser Deklaration
+ // }
+
+ public class Bicycle
+ {
+ // Felder/Variablen der Klasse "Bicycle"
+ // Das Keyword public macht das Member von überall zugänglich
+ public int Cadence
+ {
+ get // get definiert eine Methode um die Eigenschaft abzurufen
+ {
+ return _cadence;
+ }
+ set // set definiert eine Methode um die Eigenschaft zu setzen
+ {
+ _cadence = value; // value ist der dem Setter übergebene Wert
+ }
+ }
+ private int _cadence;
+
+ // Das Keyword protected macht das Member nur für die Klasse selbst
+ // und ihre Subklassen zugänglich
+ protected virtual int Gear
+ {
+ get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird
+ set;
+ }
+
+ // Das Keyword internal macht das Member innerhalb der Assembly zugänglich
+ internal int Wheels
+ {
+ get;
+ private set; // get/set kann auch über Keywords modifiziert werden
+ }
+
+ int _speed; // Member ohne vorangestellte Keywords sind standardmäßig
+ // private, sie sind nur innerhalb der Klasse zugänglich.
+ // Man kann aber natürlich auch das Keyword private benutzen.
+ private string Name { get; set; }
+
+ // Ein Enum ist ein klar definierter Satz an benannten Konstanten.
+ // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu
+ // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für
+ // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,
+ // long, oder ulong. Alle Werte in einem Enum sind eindeutig.
+ public enum BikeBrand
+ {
+ Colnago,
+ EddyMerckx,
+ Bianchi = 42, // so kann man den Wert explizit setzen
+ Kynast // 43
+ }
+ // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,
+ // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren
+
+ // Nachdem das Enum deklariert ist, können wir den Typen verwenden:
+ public BikeBrand Brand;
+
+ // Als static gekennzeichnete Member gehören dem Typ selbst,
+ // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem
+ // Objekt benutzen
+ // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");
+ static public int BicyclesCreated = 0;
+
+ // readonly-Werte werden zur Laufzeit gesetzt
+ // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor
+ // festgelegt werden
+ readonly bool _hasCardsInSpokes = false; // readonly und private
+
+ // Konstruktoren bestimmen was bei einer Instantiierung passiert.
+ // Das ist ein Default-Konstruktor:
+ public Bicycle()
+ {
+ // Member der Klasse können über das Keyword this erreicht werden
+ this.Gear = 1;
+ // oft ist das aber gar nicht nötig
+ Cadence = 50;
+ _speed = 5;
+ Name = "Bonanzarad";
+ Brand = BikeBrand.Kynast;
+ BicyclesCreated++;
+ }
+
+ // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ string name, bool hasCardsInSpokes, BikeBrand brand)
+ : base() // ruft zuerst den "base"-Konstruktor auf
+ {
+ Gear = startGear;
+ Cadence = startCadence;
+ _speed = startSpeed;
+ Name = name;
+ _hasCardsInSpokes = hasCardsInSpokes;
+ Brand = brand;
+ }
+
+ // Konstruktoren können aneinandergehängt werden:
+ public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+ this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)
+ {
+ }
+
+ // Syntax für Methoden:
+ // <public/private/protected> <return type> <function name>(<args>)
+
+ // Klassen können Getter und Setter für Werte definieren,
+ // oder diese Werte direkt als Eigenschaft implementieren
+ // (in C# der bevorzugte Weg)
+
+ // Parameter von Methoden können Default-Werte haben.
+ // "SpeedUp" kann man also auch ohne Parameter aufrufen:
+ public void SpeedUp(int increment = 1)
+ {
+ _speed += increment;
+ }
+
+ public void SlowDown(int decrement = 1)
+ {
+ _speed -= decrement;
+ }
+
+ // Eigenschaften mit get/set
+ // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu
+ // empfehlen. Diese können Getter und Setter haben, oder auch nur
+ // einen Getter bzw. einen Setter
+ private bool _hasTassles; // private Variable
+ public bool HasTassles // öffentliches Interface
+ {
+ get { return _hasTassles; }
+ set { _hasTassles = value; }
+ }
+
+ // Das kann man auch kürzer schreiben:
+ // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,
+ // (entsprechend `private bool _isBroken`) der gesetzt
+ // bzw. zurückgegeben wird:
+ public bool IsBroken { get; private set; }
+ public int FrameSize
+ {
+ get;
+ // für Getter und Setter kann der Zugriff auch einzeln
+ // beschränkt werden, FrameSize kann also nur von innerhalb
+ // der Klasse "Bicycle" gesetzt werden
+ private set;
+ }
+
+ // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:
+ public virtual string ToString()
+ {
+ return "Gang: " + Gear +
+ " Kadenz: " + Cadence +
+ " Geschwindigkeit: " + _speed +
+ " Name: " + Name +
+ " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +
+ "\n------------------------------\n"
+ ;
+ }
+
+ // Auch Methoden können als static gekennzeichnet werden, nützlich
+ // beispielsweise für Helper-Methoden
+ public static bool DidWeCreateEnoughBicyclesYet()
+ {
+ // In einer statischen Methode können wir natürlich auch nur
+ // statische Member der Klasse referenzieren
+ return BicyclesCreated > 9000;
+ }
+ // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee
+ // sein die Klasse selbst als static zu kennzeichnen
+
+ } // Ende der Klasse "Bicycle"
+
+ // "PennyFarthing" ist eine Unterklasse von "Bicycle"
+ class PennyFarthing : Bicycle
+ {
+ // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder
+ // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)
+
+ // hier wird einfach der Elternkonstruktor aufgerufen
+ public PennyFarthing(int startCadence, int startSpeed) :
+ base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)
+ {
+ }
+
+ protected override int Gear
+ {
+ get
+ {
+ return 0;
+ }
+ set
+ {
+ throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");
+ }
+ }
+
+ public override string ToString()
+ {
+ string result = "Hochrad ";
+ result += base.ToString(); // ruft die "base"-Version der Methode auf
+ return result;
+ }
+ }
+
+ // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen
+ // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:
+ interface IJumpable
+ {
+ // Alle Member eines Interfaces sind implizit public
+ void Jump(int meters);
+ }
+
+ interface IBreakable
+ {
+ // Interfaces können Eigenschaften, Methoden und Events definieren
+ bool Broken { get; }
+ }
+
+ // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige
+ // Anzahl von Interfaces implementieren
+ class MountainBike : Bicycle, IJumpable, IBreakable
+ {
+ int damage = 0;
+
+ public void Jump(int meters)
+ {
+ damage += meters;
+ }
+
+ public bool Broken
+ {
+ get
+ {
+ return damage > 100;
+ }
+ }
+ }
+
+ // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.
+ // EntityFramework Code First ist großartig
+ // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)
+ // http://msdn.microsoft.com/de-de/data/jj193542.aspx
+ public class BikeRepository : DbSet
+ {
+ public BikeRepository()
+ : base()
+ {
+ }
+
+ public DbSet<Bicycle> Bikes { get; set; }
+ }
+} // Ende des Namespaces
+```
+
+## In dieser Übersicht nicht enthalten sind die Themen:
+
+ * Flags
+ * Attributes
+ * Statische Eigenschaften
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Zum Weiterlesen gibt es viele gute Anlaufpunkte:
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)
diff --git a/de-de/css-de.html.markdown b/de-de/css-de.html.markdown new file mode 100644 index 00000000..23c1df94 --- /dev/null +++ b/de-de/css-de.html.markdown @@ -0,0 +1,230 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] +translators: + - ["Kyr", "http://github.com/kyrami"] +lang: de-de +filename: learncss-de.css +--- + +In den frühen Tagen des Internets gab es keine visuellen Elemente, alles war nur reiner Text. Aber mit der Weiterentwicklung von Browsern wurden auch vollständig visuelle Webseiten zu einem Standard. +Durch Verwendung von CSS lässt sich eine strikte Trennung zwischen HTML-Code und Designelementen erreichen. + +Kurzgefasst, CSS ermöglicht es, verschiedene HTML-Elemente innerhalb eines Dokuments auszuwählen und ihnen visuelle Eigenschaften zu geben. + +CSS hat wie jede andere Sprache viele Versionen. Hier fokussieren wir uns auf CSS2.0, welche nicht die neueste, aber die am weitesten verbreitete und unterstützte Version ist. + +**HINWEIS:** Weil die Ausgabe von CSS visuelle Eigenschaften sind, wirst du wahrscheinlich eine CSS-Sandbox wie [dabblet](http://dabblet.com/) benutzen müssen, um die Sprache richtig zu lernen. +In diesem Artikel wird am meisten auf generelle Hinweise und die Syntax geachtet. + + +```css +/* Kommentare werden in Sternchen-Schrägstrichkombinationen gepackt (genauso wie hier!) */ + +/* #################### + ## SELEKTOREN + ####################*/ + +/* Eigentlich ist das grundlegende CSS-Statement sehr simpel */ +selektor { eigenschaft: wert; /* mehr eigenschaften...*/ } + +/* Der Selektor wird dazu benutzt, ein Element auf der Seite auszuwählen. + +Man kann aber auch alle Elemente auf einer Seite auswählen! */ +* { color:red; } /* farbe:rot */ + +/* +Angenommen wir haben folgendes Element auf einer Seite: + +<div class='eine-klasse klasse2' id='eineId' attr='wert' /> +*/ + +/* kann man es so über seine Klasse auswählen */ +.eine-klasse { } + +/* oder über beide Klassen! */ +.eine-klasse.klasse2 { } + +/* oder über den Namen des Tags */ +div { } + +/* oder über seine Id */ +#eineId { } + +/* oder darüber, dass es ein Attribut hat! */ +[attr] { font-size:smaller; } + +/* oder auch darüber, dass das Attribut einen bestimmten Wert hat */ +[attr='wert'] { font-size:smaller; } + +/* beginnt mit dem übergebenen Wert */ +[attr^='we'] { font-size:smaller; } + +/* endet damit */ +[attr$='rt'] { font-size:smaller; } + +/* oder beinhaltet einen Teil davon */ +[attr~='er'] { font-size:smaller; } + + +/* Noch wichtiger ist aber die Möglichkeit, all das miteinander kombinieren +zu können - man sollte hierbei nur mit der Leerzeichensetzung vorsichtig sein, +ein Leerzeichen macht es zu zwei verschiedenen Selektoren */ + +div.eine-klasse[attr$='rt'] { } /* so ist es richtig */ + +/* Man kann auch ein Element über seine Elternelemente auswählen */ + +/* > wählt ein direktes Kind aus */ +div.ein-elternteil > .klassen-name {} + +/* Mit einem Leerzeichen getrennt kann man alle Elternelemente ansprechen */ +/* Das folgende heißt also, dass jedes Element mit der Klasse 'klassen-name' +und dem Elternteil IN JEDER TIEFE ausgewählt wird */ +div.ein-elternteil .klassen-name {} + +/* Achtung: das selbe ohne das Leerzeichen hat eine andere Bedeutung, +kannst du mir sagen, was? */ +div.ein-elternteil.klassen-name {} + +/* Man kann ein Element auch nach seinem direkten Nachbarelement +auswählen */ +.ich-bin-vorher + .dieses-element { } + +/* Oder über jedes Geschwisterelement davor */ +.ich-kann-jeder-davor-sein ~ .dieses-element {} + +/* Mit Pseudoklassen lassen sich Elemente anhand ihres momentanen Zustands +auf der Seite auswählen (anstatt über die Seitenstruktur) */ + +/* Zum Beispiel, wenn über ein Element mit dem Mauszeiger gefahren wird */ +:hover {} + +/* Oder einen bereits besuchten Link*/ +:visited {} + +/* Oder einen noch nicht besuchten Link*/ +:link {} + +/* Oder ein Eingabeelement, das zurzeit im Fokus steht */ +:focus {} + + +/* #################### + ## EIGENSCHAFTEN + ####################*/ + +selector { + + /* Einheiten */ + width: 50%; /* in Prozent */ + font-size: 2em; /* mal der derzeitigen Schriftgröße */ + width: 200px; /* in Pixeln */ + font-size: 20pt; /* in Punkten */ + width: 5cm; /* in Zentimetern */ + width: 50mm; /* in Millimetern */ + width: 5in; /* in Zoll */ + + /* Farben */ + background-color: #F6E /* in kurzem Hex */ + background-color: #F262E2 /* in langem Hex */ + background-color: tomato /* kann auch eine benannte Farbe sein */ + background-color: rgb(255, 255, 255) /* in RGB */ + background-color: rgb(10%, 20%, 50%) /* in RGB Prozent */ + background-color: rgba(255, 0, 0, 0.3); /* in semi-transparentem RGB */ + + /* Bilder */ + background-image: url(/pfad-zum-bild/image.jpg); + + /* Schriften */ + font-family: Arial; + font-family: "Courier New"; /* wenn der Name ein Leerzeichen beinhält, kommt er in + Anführungszeichen */ + font-family: "Courier New", Trebuchet, Arial; /* wird die erste Schriftart + nicht gefunden, wird die zweite benutzt, usw. */ +} + +``` + +## Benutzung + +Speichere das CSS, das du benutzen willst mit der endung '.css'. + +```xml +<!-- du musst die CSS-Datei im <head>-bereich der seite einbinden --> +<link rel='stylesheet' type='text/css' href='filepath/filename.css' /> + +<!-- Einbindung funktioniert auch inline, wobei diese Methode nicht +empfohlen ist --> +<style> + selector { property:value; } +</style> + +<!-- Oder direkt auf einem Element (sollte aber vermieden werden) --> +<div style='property:value;'> +</div> + +``` + +## Spezifität + +Ein Element kann natürlich auch von mehr als einer Regel in einem Stylesheet +angesprochen werdenm und kann eine Eigenschaft auch öfters als einmal zugewiesen +bekommen. In diesen Fällen gibt es Regeln, die die Spezifität von Selektoren regeln. + +Wir haben dieses CSS: + +```css +/*A*/ +p.klasse1[attr='wert'] + +/*B*/ +p.klasse1 {} + +/*C*/ +p.klasse2 {} + +/*D*/ +p {} + +/*E*/ +p { property: wert !important; } + +``` + +und das folgende Markup: + +```xml +<p style='/*F*/ property:value;' class='class1 class2' attr='value'> +</p> +``` + +Die Spezifität der Stile ist wie folgt: +(die Spezifität gilt nur für **einzelne Eigenschaften**, nicht für ganze Blöcke) + +* `E` hat die größte Spezifität wegen dem Schlüsselwort `!important`. + man sollte diese Form aber vermeiden. +* `F` ist als nächstes dran, da es direkt an dem element definiert ist. +* Dann folgt `A`, da es "spezifischer" als alle anderen ist. + spezifischer = mehr Zuweisungen: 1 Tagname `p` + + Klassenname `klasse1` + 1 Attribut `attr='value'` +* `C` kommt als nächstes, obwohl es genau so ist wie `B`, + es erscheint aber später im Stylesheet. +* dann kommt `B` +* und als letztes `D`. + +## Kompatibilität + +Die meisten Features von CSS sind in allen Browsern verfügbar. Man sollte +jedoch immer darauf achten die benutzten Features auf Verfügbarkeit in den +vom Projekt unterstützten Browser zu überprüfen. + +[QuirksMode CSS](http://www.quirksmode.org/css/) oder [Can I Use](http://caniuse.com/) sind zwei der besten Quellen dafür. + +## Weiterlesen + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) + diff --git a/de-de/elixir-de.html.markdown b/de-de/elixir-de.html.markdown new file mode 100644 index 00000000..29d5132d --- /dev/null +++ b/de-de/elixir-de.html.markdown @@ -0,0 +1,419 @@ +---
+language: elixir
+contributors:
+ - ["Joao Marques", "http://github.com/mrshankly"]
+translators:
+ - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]
+filename: learnelixir-de.ex
+lang: de-de
+---
+
+Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll
+kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt
+viele Features mit.
+
+```ruby
+
+# Einzeilige Kommentare werden mit der Raute gesetzt.
+
+# Es gibt keine mehrzeiligen Kommentare;
+# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander
+# zu setzen (so wie hier).
+
+# Mit 'iex' ruft man die Elixir-Shell auf.
+# Zum kompilieren von Modulen dient der Befehl 'elixirc'.
+
+# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt
+# installiert wurde.
+
+## ---------------------------
+## -- Basistypen
+## ---------------------------
+
+# Es gibt Nummern:
+3 # Integer
+0x1F # Integer
+3.0 # Float
+
+# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem
+# ':'.
+:hello # Atom
+
+# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.
+{1,2,3} # Tupel
+
+# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen
+# werden:
+elem({1, 2, 3}, 0) # => 1
+
+# Listen sind als verkettete Listen implementiert.
+[1, 2, 3] # list
+
+# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:
+[ kopf | rest ] = [1,2,3]
+kopf # => 1
+rest # => [2, 3]
+
+# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'
+# (Musterabgleich) und keine Zuweisung.
+# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.
+# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen
+# werden.
+
+# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht
+# zusammenpassen.
+# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an
+# Elementen:
+{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Es gibt außerdem 'binaries',
+<<1,2,3>> # binary.
+
+# Strings und 'char lists'
+"hello" # String
+'hello' # Char-Liste
+
+# ... und mehrzeilige Strings
+"""
+Ich bin ein
+mehrzeiliger String.
+"""
+#=> "Ich bin ein\nmehrzeiliger String.\n"
+
+# Alles Strings werden in UTF-8 enkodiert:
+"héllò" #=> "héllò"
+
+# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach
+# Listen.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c] #=> 'abc'
+
+# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.
+?a #=> 97
+
+# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'
+[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
+'hello ' ++ 'world' #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world" #=> "hello world"
+
+## ---------------------------
+## -- Operatoren
+## ---------------------------
+
+# Einfache Arithmetik
+1 + 1 #=> 2
+10 - 5 #=> 5
+5 * 2 #=> 10
+10 / 2 #=> 5.0
+
+# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.
+
+# Für Division mit ganzzahligen Ergebnis gibt es 'div'
+div(10, 2) #=> 5
+
+# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'
+rem(10, 3) #=> 1
+
+# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese
+# Operatoren erwarten einen Boolean als erstes Argument.
+true and true #=> true
+false or true #=> true
+# 1 and true #=> ** (ArgumentError) argument error
+
+# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs
+# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.
+1 || true #=> 1
+false && 1 #=> false
+nil && 20 #=> nil
+
+!true #=> false
+
+# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,
+# `<` und `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2 #=> true
+
+# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:
+1 == 1.0 #=> true
+1 === 1.0 #=> false
+
+# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:
+1 < :hello #=> true
+
+# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:
+# number < atom < reference < functions < port < pid < tuple < list < bitstring
+
+# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a
+# total ordering is well defined is important."
+
+## ---------------------------
+## -- Kontrollstrukturen
+## ---------------------------
+
+# Es gibt die `if`-Verzweigung
+if false do
+ "Dies wird nie jemand sehen..."
+else
+ "...aber dies!"
+end
+
+# ...und ebenso `unless`
+unless true do
+ "Dies wird nie jemand sehen..."
+else
+ "...aber dies!"
+end
+
+# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir
+# arbeiten damit.
+
+# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.
+case {:one, :two} do
+ {:four, :five} ->
+ "Das wird nicht passen"
+ {:one, x} ->
+ "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."
+ _ ->
+ "Dieser Fall greift immer."
+end
+
+# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert
+# nicht weiter verwendet wird.
+# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:
+[kopf | _] = [1,2,3]
+kopf #=> 1
+
+# Für bessere Lesbarkeit können wir auch das Folgende machen:
+[kopf | _rest] = [:a, :b, :c]
+kopf #=> :a
+
+# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man
+# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.
+cond do
+ 1 + 1 == 3 ->
+ "Ich werde nie aufgerufen."
+ 2 * 5 == 12 ->
+ "Ich auch nicht."
+ 1 + 2 == 3 ->
+ "Aber ich!"
+end
+
+# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert.
+cond do
+ 1 + 1 == 3 ->
+ "Ich werde nie aufgerufen."
+ 2 * 5 == 12 ->
+ "Ich auch nicht."
+ true ->
+ "Aber ich! (dies ist im Grunde ein 'else')"
+end
+
+# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.
+# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,
+# egal ob zuvor ein Wert gefangen wurde.
+try do
+ throw(:hello)
+catch
+ nachricht -> "#{nachricht} gefangen."
+after
+ IO.puts("Ich bin die 'after'-Klausel.")
+end
+#=> Ich bin die 'after'-Klausel.
+# ":hello gefangen"
+
+## ---------------------------
+## -- Module und Funktionen
+## ---------------------------
+
+# Anonyme Funktionen (man beachte den Punkt)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben
+# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'
+# eingeführt:
+f = fn
+ x, y when x > 0 -> x + y
+ x, y -> x * y
+end
+
+f.(1, 3) #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen
+# Geltungsbereich ('scope') verfügbar.
+is_number(10) #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines
+# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu
+# definieren.
+defmodule Math do
+ def sum(a, b) do
+ a + b
+ end
+
+ def square(x) do
+ x * x
+ end
+end
+
+Math.sum(1, 2) #=> 3
+Math.square(3) #=> 9
+
+# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'
+# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen
+# werden: elixirc math.ex
+
+# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine
+# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen
+# werden; eine private Funktion kann nur lokal angesprochen werden.
+defmodule PrivateMath do
+ def sum(a, b) do
+ do_sum(a, b)
+ end
+
+ defp do_sum(a, b) do
+ a + b
+ end
+end
+
+PrivateMath.sum(1, 2) #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:
+defmodule Geometry do
+ def area({:rectangle, w, h}) do
+ w * h
+ end
+
+ def area({:circle, r}) when is_number(r) do
+ 3.14 * r * r
+ end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3}) #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger
+# Bestandteil von Elixir.
+defmodule Recursion do
+ def sum_list([head | tail], acc) do
+ sum_list(tail, acc + head)
+ end
+
+ def sum_list([], acc) do
+ acc
+ end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso
+# ist es möglich eigene Attribute hinzuzufügen.
+defmodule MyMod do
+ @moduledoc """
+ Dies ist ein eingebautes Attribut in einem Beispiel-Modul
+ """
+
+ @my_data 100 # Dies ist ein selbst-definiertes Attribut.
+ IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- 'Records' und Ausnahmebehandlung
+## ---------------------------
+
+# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen
+# Namen zuzuweisen.
+defrecord Person, name: nil, age: 0, height: 0
+
+joe_info = Person.new(name: "Joe", age: 30, height: 180)
+#=> Person[name: "Joe", age: 30, height: 180]
+
+# Zugriff auf den Wert von 'name'
+joe_info.name #=> "Joe"
+
+# Den Wert von 'age' überschreiben
+joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
+
+# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,
+# um Ausnahmen beziehungsweise Fehler zu behandeln.
+try do
+ raise "Irgendein Fehler."
+rescue
+ RuntimeError -> "Laufzeit-Fehler gefangen."
+ _error -> "Und dies fängt jeden Fehler."
+end
+
+# Alle Ausnahmen haben das Attribut 'message'
+try do
+ raise "ein Fehler"
+rescue
+ x in [RuntimeError] ->
+ x.message
+end
+
+## ---------------------------
+## -- Nebenläufigkeit
+## ---------------------------
+
+# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles
+# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei
+# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen.
+
+# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die
+# wiederum eine Funktion als Argument entgegen nimmt.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann
+# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um
+# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir
+# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem
+# 'receive'-Mechanismus sichergestellt:
+defmodule Geometry do
+ def area_loop do
+ receive do
+ {:rectangle, w, h} ->
+ IO.puts("Area = #{w * h}")
+ area_loop()
+ {:circle, r} ->
+ IO.puts("Area = #{3.14 * r * r}")
+ area_loop()
+ end
+ end
+end
+
+# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion
+# in der Shell mit, etwa so:
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck
+# erfüllt:
+pid <- {:rectangle, 2, 3}
+#=> Area = 6
+# {:rectangle,2,3}
+
+pid <- {:circle, 2}
+#=> Area = 12.56000000000000049738
+# {:circle,2}
+
+# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man
+# die aktuelle pid herausfinden.
+self() #=> #PID<0.27.0>
+
+```
+
+## Referenzen und weitere Lektüre
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert
+* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown new file mode 100644 index 00000000..43939129 --- /dev/null +++ b/de-de/git-de.html.markdown @@ -0,0 +1,374 @@ +--- +category: tool +tool: git +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["kultprok", "http://www.kulturproktologie.de"] +lang: de-de +--- + +Git ist eine verteilte Versions- und Quellcodeverwaltung. + +Es nimmt Schnappschüsse der Projekte, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können. + +Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit* oder *Head* sind idiomatische Bestandteile im Umgang mit Git. Sie wurden nicht übersetzt. + +## Konzepte der Versionsverwaltung + +### Was ist Versionsverwaltung? + +Eine Versionskontrolle erfasst die Änderungen einer Datei oder eines Verzeichnisses im Verlauf der Zeit. + +### Zentrale im Vergleich mit verteilter Versionverwaltung + +* Zentrale Versionskontrolle konzentriert sich auf das Synchronisieren, Verfolgen und Sichern von Dateien. +* Verteilte Versionskontrolle konzentriert sich auf das Teilen der Änderungen. Jede Änderung hat eine eindeutige ID. +* Verteilte Systeme haben keine vorbestimmte Struktur. Ein SVN-ähnliches, zentrales System wäre mit Git ebenso umsetzbar. + +[Weiterführende Informationen](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### Warum Git? + +* Ist offline einsetzbar. +* Einfache Kollaboration! +* Branching ist einfach! +* Merging ist einfach! +* Git ist schnell. +* Git ist flexibel. + +## Die Architektur von Git + + +### Repository (Repo) + +Ein Satz von Dateien, Verzeichnisen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben. + +Ein Repository besteht in Git aus dem .git-Verzeichnis und dem Arbeitsverzeichnis. + +### .git-Verzeichnis (Teil des Repositorys) + +Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und mehr. +[Ausführliche Übersicht](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### Arbeitsverzeichnis (Teil des Repositorys) + +Dies sind die Verzeichnisse und Dateien in deinem Repository. + +### Index (Teil des .git-Verzeichnisses) + +Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht. + +### Commit + +Ein Commit ist ein Schnappschuss von Uderungen in deinem Arbeitsverzeichnis. Wenn du zum Beispiel 5 Dateien hinzugefügt und 2 andere entfernt hast, werden diese Änderungen im Commit (Schnappschuss) enthalten sein. Dieser Commit kann dann in andere Repositorys gepusht werden. Oder nicht! + +### Branch + +Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf Stand gebracht und zeigt dann auf den neuen letzten Commit. + +### HEAD und head (Teil des .git-Verzeichnisses) + +HEAD ist ein Pointer auf den aktuellen Branch. Ein Repository hat nur einen *aktiven* HEAD. Ein head ist ein Pointer, der auf ein beliebige Zahl von heads zeigt. + +### Konzeptionelle Hintergründe + +* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/) +* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html) + + +## Befehle + + +### init + +Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt. + +```bash +$ git init +``` + +### config + +Hiermit werden Einstellungen vorgenommen. Dies kann das Repository, das System selbst oder globale Einstellungen betreffen. + +```bash +# Grundlegende Config-Variablen ausgeben und setzen +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[Mehr über git config](http://git-scm.com/docs/git-config) + +### help + +Schnellzugriff auf extrem detaillierte Anleitungen zu allen Befehlen. Oder als Erinnerung zu semantischen Eigenheiten. + +```bash +# Übersicht gängiger Befehle +$ git help + +# Übersicht aller verfügbaren Befehle +$ git help -a + +# Befehlspezifische Hilfe - Bedienungsanleitung +# git help <gesuchter_befehl> +$ git help add +$ git help commit +$ git help init +``` + +### status + +Zeigt die Unterschiede zwischen Index (im Grunde dein Arbeitsverzeichnis/-repository) und dem aktuellen HEAD an. + + +```bash +# Zeigt den Branch, nicht-verfolgte Dateien, Uderungen und andere Unterschiede an +$ git status + +# Anderes Wissenswertes über git status anzeigen +$ git help status +``` + +### add + +Hinzufügen von Dateien zum Arbeitsverzeichnis/-repository. Wenn du neue Dateien nicht mit *git add* zum Arbeitsverzeichnis hinzufügst, werden sie nicht in den Commit aufgenommen! + +```bash +# Fügt eine Datei deinem aktuellen Arbeitsverzeichnis hinzu +$ git add HelloWorld.java + +# Fügt eine Datei aus einem verschachtelten Verzeichnis hinzu +$ git add /path/to/file/HelloWorld.c + +# Reguläre Ausdrücke werden unterstützt! +$ git add ./*.java +``` + +### branch + +Verwalte alle Branches. Du kannst sie mit diesem Befehl ansehen, bearbeiten, neue erschaffen oder löschen. + +```bash +# Liste alle bestehenden Branches und Remotes auf +$ git branch -a + +# Erstelle einen neuen Branch +$ git branch myNewBranch + +# Lösche einen Branch +$ git branch -d myBranch + +# Benenne einen Branch um +# git branch -m <oldname> <newname> +$ git branch -m myBranchName myNewBranchName + +# Ändere die Beschreibung eines Branchs +$ git branch myBranchName --edit-description +``` + +### checkout + +Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angegebenen Branches. + +```bash +# Ein Repo auschecken - wenn nicht anders angegeben ist das der master +$ git checkout +# Einen bestimmten Branch auschecken +$ git checkout branchName +# Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>" +$ git checkout -b newBranch +``` + +### clone + +Ein bestehendes Repository in ein neues Verzeichnis klonen oder kopieren. Es fügt außerdem für hedes geklonte Repo remote-tracking Branches hinzu. Du kannst auf diese Remote-Branches pushen. + +```bash +# Klone learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git +``` + +### commit + +Speichert die aktuellen Inhalte des Index in einen neuen *Commit*. Dieser Commit enthält alle Änderungen und eine vom Benutzer erstellte Beschreibung der Änderungen. + +```bash +# Commit mit Beschreibung erstellen. +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +``` + +### diff + +Zeigt die Unterschiede zwischen Dateien von Arbeitsverzeichnisse, dem Index und Commits an. + +```bash +# Unterschiede zwischen deinem Arbeitsverzeichnis und dem Index anzeigen +$ git diff + +# Unterschiede zwischen dem Index und dem aktuellsten Commit anzeigen +$ git diff --cached + +# Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen +$ git diff HEAD +``` + +### grep + +Schnell ein Repository durchsuchen. + +Optionale Einstellungen: + +```bash +# Vielen Dank an Travis Jeffery für die Hinweise. +# Zeilennummerierung in grep-Suchergebnissen +$ git config --global grep.lineNumber true + +# Suchergebnisse lesbarer gestalten, auch Gruppierungen sind möglich +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Suche nach "variableName" in allen java-Dateien +$ git grep 'variableName' -- '*.java' + +# Suche nach eine Zeile, die "arrayListName" und "add" oder "remove" enthält +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +Google ist dein Freund; für mehr Beispiele: +[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Zeige Commits für das Repository an. + +```bash +# Zeige alle Commits +$ git log + +# Zeige die Anzahl n an Commits +$ git log -n 10 + +# Zeige nur Merges an +$ git log --merges +``` + +### merge + +*Merge*, also verschmelze, alle Änderungen von externen Commits in den aktuellen Branch. + +```bash +# Merge den angegebenen Branch in den aktuellen. +$ git merge branchName + +# Erstelle immer einen Merge-Commit. +$ git merge --no-ff branchName +``` + +### mv + +Eine Datei umbenennen oder verschieben. + +```bash +# Umbenennen +$ git mv HelloWorld.c HelloNewWorld.c + +# Verschieben +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Umbenennung oder Verschieben erzwingen +# "existingFile" besteht schon im Verzeichnis, wird überschrieben mit "myFile" +$ git mv -f myFile existingFile +``` + +### pull + +Führe einen Pull, zieht alle Daten, eines Repositorys und f?? einen Merge mit einem anderen Branch durch. + +```bash +# Update deines lokalen Repos, indem ein Merge der neuen Uderungen +# von den remote-liegenden "origin"- und "master"-Branches durchgef?? wird. +# git pull <remote> <branch> +# git pull => impliziter Verweis auf origin und master +$ git pull origin master + +# F?? einen Merge von Uderungen eines remote-Branch und ein Rebase +# des Branch-Commits im lokalen Repo durch. Wie: pull <remote> <branch>, git rebase <branch>" +$ git pull origin master --rebase +``` + +### push + +Führe einen Push, ein Hochladen, und einen Merge von Änderungen eines remote-Branch mit einem Branch aus. + +```bash +# Führe Push und Merge von Änderungen des lokalen Repo zu einem +# remote-Branch namens "origin" und dem "master"-Branch aus. +# git push <remote> <branch> +# git push => impliziter Verweis auf => git push origin master +$ git push origin master +``` + +### rebase (mit Vorsicht einsetzen) + +Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden. + +```bash +# Rebase "experimentBranch" in den "master"-Branch +# git rebase <basisbranch> <themenbranch> +$ git rebase master experimentBranch +``` + +[Weiterführende Informationen](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (mit Vorsicht einsetzen) + +Setze den aktuellen HEAD auf den angegebenen Zustand zurück. So können Merges, Pulls, Commits, Hinzufügungen und andere Änderungen rückgängig gemacht werden. Es ist ein hervorragender Befehl, aber auch sehr gefährlich, wenn du nicht weißt, was du tust. + +```bash +# Setze die Staging-Area zurück, um dem letzten Commit zu entsprechen (das Verzeichnis bleibt unberührt) +$ git reset + +# Setze die Staging-Area zurück, um dem letzten Commit zu entsprechen und überschreibe das Arbeitsverzeichnis +$ git reset --hard + +# Bewegt die Spitze des Branches zu dem angegebenen Commit (das Verzeichnis bleibt unber??) +# Alle Uderungen bleiben im Verzeichnis erhalten +$ git reset 31f2bb1 + +# Bewegt die Spitze des Branches zurück zu dem angegebenen Commit +# und gleicht die Arbeitsverzeichnisse ab (löscht nicht vom Commit erfasste Änderungen und alle Commits, +# die dem angegebenen Commit folgen). +$ git reset --hard 31f2bb1 +``` + +### rm + +Das Gegenteil von *git add*. *git rm* löscht Dateien vom Arbeitsverzeichnis. + +```bash +# Entferne HelloWorld.c +$ git rm HelloWorld.c + +# Entferne eine Datei aus einem verschachtelten Verzeichnis +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## Weiterführende Informationen + +* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) + +* [git-scm - Video Tutorials](http://git-scm.com/videos) + +* [git-scm - Documentation](http://git-scm.com/docs) + +* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown new file mode 100644 index 00000000..765372e0 --- /dev/null +++ b/de-de/go-de.html.markdown @@ -0,0 +1,318 @@ +--- +language: Go +filename: learngo-de.go +contributors: + - ["Joseph Adams", "https://github.com/jcla1"] +lang: de-de +--- +Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in +der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in +der realen Welt zu lösen. + +Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung +und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu +verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern +Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große +Programmierprojekte. + +Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine +aktive Community. + +```go +// Einzeiliger Kommentar +/* Mehr- + zeiliger Kommentar */ + +// Eine jede Quelldatei beginnt mit einer Paket-Klausel. +// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm +// einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek +// deklariert. +package main + +// Ein "import" wird verwendet, um Pakete zu deklarieren, die in dieser +// Quelldatei Anwendung finden. +import ( + "fmt" // Ein Paket in der Go Standardbibliothek + "net/http" // Ja, ein Webserver. + "strconv" // Zeichenkettenmanipulation +) + +// Es folgt die Definition einer Funktions, in diesem Fall von "main". Auch hier +// ist der Name wieder besonders. "main" markiert den Eintrittspunkt des +// Programms. Vergessen Sie nicht die geschweiften Klammern! +func main() { + // Println gibt eine Zeile zu stdout aus. + // Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt. + fmt.Println("Hello world!") + + // Aufruf einer weiteren Funktion definiert innerhalb dieses Pakets. + beyondHello() +} + +// Funktionen können Parameter akzeptieren, diese werden in Klammern deklariert, +// die aber auch bei keinen Parametern erforderlich sind. +func beyondHello() { + var x int // Deklaration einer Variable, muss vor Gebrauch geschehen. + x = 3 // Zuweisung eines Werts. + // Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu + // folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen. + y := 4 + + // Eine Funktion mit mehreren Rückgabewerten. + sum, prod := learnMultiple(x, y) + + fmt.Println("sum:", sum, "prod:", prod) // Simple Ausgabe + learnTypes() // In < y Minuten lernen Sie mehr! +} + +// Funktionen können mehrere Parameter und (mehrere!) Rückgabewerte haben. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Wiedergabe zweier Werte +} + +// Überblick über einige eingebaute Typen und Literale. +func learnTypes() { + // Kurze Deklarationen sind die Norm. + s := "Lernen Sie Go!" // Zeichenketten-Typ + + s2 := `Eine "raw" Zeichenkette kann +Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ + + // nicht-ASCII Literal. Go Quelltext ist UTF-8 kompatibel. + g := 'Σ' // Ein Runen-Typ, alias int32, gebraucht für unicode code points. + + f := 3.14195 // float64, eine IEEE-754 64-bit Dezimalzahl + c := 3 + 4i // complex128, besteht intern aus zwei float64-er + + // "var"-Syntax mit Initalwert + var u uint = 7 // Vorzeichenlos, aber die Größe ist implementationsabhängig + var pi float32 = 22. / 7 + + // Umwandlungs-Syntax mit kurzer Deklaration + n := byte('\n') // byte ist ein Alias für uint8 + + // Arrays haben bei Kompile-Zeit festgelegte Größen + var a4 [4]int // Ein Array mit 4 ints, alle mit Initialwert 0 + a3 := [...]int{3, 1, 5} // Ein Array mit 4 ints, Initialwerte wie angezeigt + + // "slices" haben eine dynamische Größe. Arrays und Slices haben beide ihre + // Vorzüge, aber slices werden viel häufiger verwendet + s3 := []int{4, 5, 9} // Vergleichen Sie mit a3, hier: keine Ellipse + s4 := make([]int, 4) // Weist Speicher für 4 ints zu, alle mit Initialwert 0 + var d2 [][]float64 // Nur eine Deklaration, keine Speicherzuweisung + bs := []byte("eine slice") // Umwandlungs-Syntax + + p, q := learnMemory() // Deklariert p & q als Zeiger zu einer int. + fmt.Println(*p, *q) // Die gibt die zwei Werte aus. "*" für den Zugriff + + // "Maps" sind dynamische Datenstrukturen mit variabler Größe. Sie sind wie + // "hashs" oder "dictionaries" aus anderen Sprachen. + m := map[string]int{"drei": 3, "vier": 4} + m["eins"] = 1 + + // Ungebrauchte Variablen sind Fehler in Go + // Der Unterstrich wird verwendet, um einen Wert zu verwerfen. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Die Ausgabe zählt natürlich auch als Gebrauch + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // Auf zum Kontrollfluss! +} + +// Go ist komplett "garbage collected". Sie unterstützt Zeiger (pointers) aber +// keine Zeiger-Rechnungen. Fehler können sich durch "nil" einschleichen, jedoch +// nicht durch erhöhen eines Zeigers. +func learnMemory() (p, q *int) { + // Die bennanten Rückgabewerte p & q sind vom Typ *int + p = new(int) // Eingebaute Funktion "new" weist neuen Speicherplatz zu + // Der zugewiesene Speicher ist mit 0 initialisiert, p ist nicht länger nil + s := make([]int, 20) // So weist man 20 ints nebeneinander (im Speicher) zu + s[3] = 7 // Einer von ihnen wird ein Wert zugewiesen + r := -2 // Deklaration einer weiteren lokalen Variable + return &s[3], &r // & gibt die Addresse einer Variable +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // Bedingte Anweisungen verlangen nach geschweiften Klammern, normale + // Klammern um die Bedingung werden aber nicht gebraucht. + if true { + fmt.Println("hab's dir ja gesagt!") + } + // Die Formatierung ist durch den Befehl "go fmt" standardisiert + if false { + // nicht hier + } else { + // sonder hier! spielt die Musik + } + + // Benutzen Sie ein "switch" Statement anstatt eine Anreihung von if-s + x := 1 + switch x { + case 0: + case 1: + // Einzelne Fälle fallen nicht zum nächsten durch! + case 2: + // wird nicht ausgeführt + } + // Wie bei "if", braucht "for" auch keine Klammern um die Bedingung + for x := 0; x < 3; x++ { // ++ ist ein Statement + fmt.Println(x, "-te Iteration") + } + // Ab hier gilt wieder: x == 1 + + // For ist die einzige Schleifenform in Go, sie hat aber mehrere Formen: + for { // Endloschleife + break // nur ein Spaß + continue // wird nie ausgeführt + } + + // Wie bei for, bedeutet := in einer bedingten Anweisung zunächst die + // Zuweisung und erst dann die Überprüfung der Bedingung. + if y := expensiveComputation(); y > x { + x = y + } + // Funktionsliterale sind "closures" + xBig := func() bool { + return x > 100 // Verweist auf x, deklariert vor dem switch + } + fmt.Println("xBig:", xBig()) // true (im moment gilt: x == 1e6) + x /= 1e5 // dies macht x == 10 + fmt.Println("xBig:", xBig()) // jetzt: false + + // Wenn Sie's brauchen, werden Sie's lieben! + goto love +love: + + learnInterfaces() // Jetzt zum interessanten Teil! +} + +// Definiere "Stringer" als ein Interface mit einer Methode: String +type Stringer interface { + String() string +} + +// Definiere ein Paar als struct mit zwei Feldern, Integers mit Namen x & y. +type pair struct { + x, y int +} + +// Definiere eine Methode von "pair". Dieser Typ erfüllt jetzt das Stringer interface. +func (p pair) String() string { // p ist der Empfänger + // Sprintf ist eine weitere öffentliche Funktion von fmt. + // Der Syntax mit Punkt greift auf die Felder zu. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Der Klammer-Syntax ist ein "struct literal". Es ist ein vollkommen + // initialisiertes struct. Der := Syntax deklariert und initialisiert p. + p := pair{3, 4} + fmt.Println(p.String()) // Aufruf der String() Methode von p. + var i Stringer // Deklariere i vom Typ: Stringer + i = p // Ok, weil p auch vom Typ Stringer ist. + // Aufruf der String Methode von i, gleiche Ausgabe wie zuvor. + fmt.Println(i.String()) + + // Funktionen des fmt-Pakets rufen die String() Methode auf um eine + // druckbare Variante des Empfängers zu erhalten. + fmt.Println(p) // gleiche Ausgabe wie zuvor + fmt.Println(i) // und wieder die gleiche Ausgabe wie zuvor + + learnErrorHandling() +} + +func learnErrorHandling() { + // Das ", ok" Idiom wird häufig verwendet um zu überprüfen ob etwas schief + // gegangen ist. + m := map[int]string{3: "drei", 4: "vier"} + if x, ok := m[1]; !ok { // ok wird false sein, da 1 nicht in der map ist. + fmt.Println("keine eins gefunden") + } else { + fmt.Print(x) // x wäre der Wert, wenn er in der map wäre. + } + // Ein Fehler-Wert (error value) gibt mehr Informationen über den Grund für + // das Problem an. + if _, err := strconv.Atoi("nicht-int"); err != nil { // _ verwirft den Wert + // Gibt: "strconv.ParseInt: parsing "nicht-int": invalid syntax" aus + fmt.Println(err) + } + // Wir kommen bald nochmal auf Interfaces zurück. Aber inzwischen: + learnConcurrency() +} + +// c ist ein Kanal, ein sicheres Kommunikationsmedium. +func inc(i int, c chan int) { + c <- i + 1 // <- ist der "send" Operator, wenn ein Kanal auf der Linken ist +} + +// Wir verwenden "inc" um Zahlen parallel zu erhöhen. +func learnConcurrency() { + // Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für + // maps, slices und Kanäle. + c := make(chan int) + // Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently) + // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal. + go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine + go inc(10, c) + go inc(-805, c) + // Auslesen und dann Ausgeben der drei berechneten Werte. + // Man kann nicht im voraus feststellen in welcher Reihenfolge die Werte + // ankommen. + fmt.Println(<-c, <-c, <-c) // mit dem Kannal rechts ist <- der Empfangs-Operator + + cs := make(chan string) // ein weiterer Kannal, diesmal für strings + cc := make(chan chan string) // ein Kannal für string Kannäle + + // Start einer neuen Goroutine, nur um einen Wert zu senden + go func() { c <- 84 }() + go func() { cs <- "wortreich" }() // schon wieder, diesmal für + // "select" hat eine Syntax wie ein switch Statement, aber jeder Fall ist + // eine Kanaloperation. Es wählt einen Fall zufällig aus allen, die + // kommunikationsbereit sind, aus. + select { + case i := <-c: // der empfangene Wert kann einer Variable zugewiesen werden + fmt.Printf("es ist ein: %T", i) + case <-cs: // oder der Wert kann verworfen werden + fmt.Println("es ist eine Zeichenkette!") + case <-cc: // leerer Kanal, nicht bereit für den Empfang + fmt.Println("wird nicht passieren.") + } + // Hier wird eine der beiden Goroutines fertig sein, die andere nicht. + // Sie wird warten bis der Wert den sie sendet von dem Kannal gelesen wird. + + learnWebProgramming() // Go kann es und Sie hoffentlich auch bald. +} + +// Eine einzige Funktion aus dem http-Paket kann einen Webserver starten. +func learnWebProgramming() { + // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse, an die + // sich angeschlossen werden soll. + // Der zweite Parameter ist ein Interface, speziell: ein http.Handler + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // Fehler sollte man nicht ignorieren! +} + +// Wir lassen "pair" das http.Handler Interface erfüllen, indem wir seine einzige +// Methode implementieren: ServeHTTP +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Senden von Daten mit einer Methode des http.ResponseWriter + w.Write([]byte("Sie habe Go in Y Minuten gelernt!")) +} +``` + +## Weitere Resourcen +Alles zu Go finden Sie auf der [offiziellen Go Webseite](http://golang.org/). +Dort können sie der Tutorial folgen, interaktiv Quelltext ausprobieren und viel +Dokumentation lesen. + +Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr +kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen +ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/). +Gut dokumentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil +verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen +in der [offiziellen Dokumentation von Go](http://golang.org/pkg/). + diff --git a/de-de/haskell-de.html.markdown b/de-de/haskell-de.html.markdown new file mode 100644 index 00000000..2c548961 --- /dev/null +++ b/de-de/haskell-de.html.markdown @@ -0,0 +1,425 @@ +--- +language: Haskell +lang: de-de +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Henrik Jürges", "https://github.com/santifa"] +filename: haskell-de.hs + +--- + +Haskell wurde als praktische und funktionale Sprache entworfen. +Es ist berühmt für das Schema der Monaden und des Typsystems, aber +es sticht vor allem die Einfachheit und Eleganz hervor. + +```haskell +-- Einfache Kommentare beginnen mit 2 Bindestriche. +{- So wird ein Kommentar +über mehrere Zeilen angelegt. +-} + +---------------------------------------------------- +-- 1. Primitive Datentypen und Operatoren +---------------------------------------------------- + +-- Normale Zahlen. +3 -- 3 + +-- Einfache Rechenoperationen. +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- Die Division ist per se auf Fließkommazahlen. +35 / 4 -- 8.75 + +-- Ganzzahlige Division +35 `div` 4 -- 8 + +-- Boolesche Werte sind Primitiven. +True +False + +-- Logik Operationen +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- `not` ist eine Funktion die ein Argument entgegenimmt. +-- Haskell benötigt keine Klammern um Argumente. +-- Sie werden einfach aufgelistet: func arg1 arg2 arg3... +-- Wie man Funktionen definiert kommt weiter unten. + + +-- Strings und Zeichen +"Das ist ein String." +'a' -- Zeichen +'Einfache Anfuehrungszeichen gehen nicht.' -- error! + +-- Strings können konkateniert werden. +"Hello " ++ "world!" -- "Hello world!" + +-- Ein String ist eine Liste von Zeichen. +"Das ist eine String" !! 0 -- 'D' + + +---------------------------------------------------- +-- Listen und Tupel +---------------------------------------------------- + +-- Jedes Element einer Liste muss vom gleichen Typ sein. +-- Zwei gleiche Listen +[1, 2, 3, 4, 5] +[1..5] + +-- Haskell unterstuetzt unendliche Listen! +[1..] -- Die Liste aller natuerlichen Zahlen + +-- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation" +-- unterstuetzt. Haskell evaluiert erst etwas, wenn es benötigt wird. +-- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir: + +[1..] !! 999 -- 1000 + +-- Haskell evaluiert nun die ersten 1 - 1000 Elemente, aber der Rest der Liste +-- bleibt unangetastet. Haskell wird sie solange nicht weiterevalieren +-- bis es muss. + +-- Zwei Listen konkatenieren +[1..5] ++ [6..10] + +-- Ein Element als Head hinzufuegen +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- Gibt den 5. Index zurueck +[0..] !! 5 -- 5 + +-- Weitere Listenoperationen +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +-- list comprehensions | Listen erschaffen +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +-- Mit Bedingungen +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Tupel haben eine feste Länge, jedes Element darf aber ein anderen Typ haben. +-- Ein Tupel: +("haskell", 1) + +-- Auf Elemente eines Tupels zugreifen: +fst ("haskell", 1) -- "haskell" +snd ("haskell", 1) -- 1 + +---------------------------------------------------- +-- 3. Funktionen +---------------------------------------------------- +-- Eine einfache Funktion die zwei Argumente hat. +add a b = a + b + +-- Wenn man ghci (den Haskell Interpreter) benutzt, muss ein `let` davor. +-- let add a b = a + b + +-- Eine Funktion aufrufen +add 1 2 -- 3 + +-- Man kann eine Funktion auch Infix verwenden, +-- wenn man sie mit backticks umgibt +1 `add` 2 -- 3 + +-- So sieht die Definition eines eigenen Operators aus. +-- Also einer Funktion deren Name aus Symbolen besteht. +-- Die Integer Division: +(//) a b = a `div` b +35 // 4 -- 8 + +-- Guards sind eine einfache Möglichkeit fuer Fallunterscheidungen. +fib x + | x < 2 = x + | otherwise = fib (x - 1) + fib (x - 2) + +-- Pattern Matching funktioniert ähnlich. +-- Hier sind drei Definitionen von fib. Haskell wird automatisch +-- die erste Funktionen nehmen die dem Pattern der Eingabe entspricht. +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Pattern matching auf Tupeln: +foo (x, y) = (x + 1, y + 2) + +-- Pattern matching auf Listen. +-- `x` ist das erste Element der Liste und `xs` der Rest der Liste. +-- Damit können wir unsere eigene map Funktion bauen: +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- Anonyme Funktionen (Lambda-Funktionen) werden mit einem +-- Backslash eingeleitet, gefolgt von allen Argumenten. +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- Fold (`inject` in einigen Sprachen) +-- Foldl1 bedeutet: fold von links nach rechts und nehme den ersten +-- Wert der Liste als Basiswert f[r den Akkumulator. +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Mehr Funktionen +---------------------------------------------------- + +-- currying: Wenn man nicht alle Argumente an eine Funktion uebergibt, +-- so wird sie eine neue Funktion gebildet ("curried"). +-- Es findet eine partielle Applikation statt und die neue Funktion +-- nimmt die fehlenden Argumente auf. + +add a b = a + b +foo = add 10 -- foo ist nun Funktion die ein Argument nimmt und 10 addiert +foo 5 -- 15 + +-- Ein alternativer Weg +foo = (+10) +foo 5 -- 15 + +-- Funktionskomposition +-- Die (.) Funktion verkettet Funktionen. +-- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und +-- multipliziert dieses Ergebnis mit 5. +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + + +-- Haskell hat eine Funktion `$`. Diese ändert den Vorrang, +-- so dass alles links von ihr zuerst berechnet wird und +-- und dann an die rechte Seite weitergegeben wird. +-- Mit `.` und `$` kann man sich viele Klammern ersparen. + +-- Vorher +(even (fib 7)) -- true + +-- Danach +even . fib $ 7 -- true + +---------------------------------------------------- +-- 5. Typensystem +---------------------------------------------------- + +-- Haskell hat ein sehr starkes Typsystem. +-- Alles hat einen Typ und eine Typsignatur. + +-- Einige grundlegende Typen: +5 :: Integer +"hello" :: String +True :: Bool + +-- Funktionen haben genauso Typen. +-- `not` ist Funktion die ein Bool annimmt und ein Bool zurueckgibt: +-- not :: Bool -> Bool + +-- Eine Funktion die zwei Integer Argumente annimmt: +-- add :: Integer -> Integer -> Integer + +-- Es ist guter Stil zu jeder Funktionsdefinition eine +-- Typdefinition darueber zu schreiben: +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. If-Anweisung und Kontrollstrukturen +---------------------------------------------------- + +-- If-Anweisung: +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- If-Anweisungen können auch ueber mehrere Zeilen verteilt sein. +-- Das Einruecken ist dabei äußerst wichtig. +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- Case-Anweisung: Zum Beispiel "commandline" Argumente parsen. +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + +-- Haskell nutzt Rekursion anstatt Schleifen. +-- map wendet eine Funktion auf jedes Element einer Liste an. + +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- So kann man auch eine for-Funktion kreieren. +for array func = map func array + +-- und so benutzt man sie: +for [0..5] $ \i -> show i + +-- wir hätten sie auch so benutzen können: +for [0..5] show + +-- foldl oder foldr reduziren Listen auf einen Wert. +-- foldl <fn> <initial value> <list> +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- die Abarbeitung sieht so aus: +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl ist linksseitig und foldr rechtsseitig. +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- die Abarbeitung sieht so aus: +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. Datentypen +---------------------------------------------------- + +-- So kann man seine eigenen Datentypen in Haskell anlegen: + +data Color = Red | Blue | Green + +-- Nun können wir sie in einer Funktion benutzen. + +say :: Color -> String +say Red = "You are Red!" +say Blue = "You are Blue!" +say Green = "You are Green!" + +-- Datentypen können auch Parameter aufnehmen: + +data Maybe a = Nothing | Just a + +-- Diese sind alle vom Typ Maybe: +Just "hello" -- vom Typ `Maybe String` +Just 1 -- vom Typ `Maybe Int` +Nothing -- vom Typ `Maybe a` fuer jedes `a` + +---------------------------------------------------- +-- 8. Haskell IO +---------------------------------------------------- + +-- IO kann nicht völlig erklärt werden ohne Monaden zu erklären, +-- aber man kann die grundlegenden Dinge erklären. + +-- Wenn eine Haskell Programm ausgefuehrt wird, so wird `main` aufgerufen. +-- Diese muss etwas vom Typ `IO ()` zurueckgeben. Zum Beispiel: + +main :: IO () +main = putStrLn $ "Hello, sky! " ++ (say Blue) +-- putStrLn hat den Typ String -> IO () + +-- Es ist am einfachsten, wenn man sein Programm als Funktion von +-- String nach String implementiert. +-- Zum Beispiel die Funktion interact :: (String -> String) -> IO () +-- nimmt einen Text, tut etwas damit und gibt diesen wieder aus. + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- Man kann den Typ `IO ()` als Repräsentation einer Sequenz von +-- Aktionen sehen, die der Computer abarbeiten muss. +-- Wie bei einem Programm das in einer Imperativen Sprache geschreiben wurde. +-- Mit der `do` Notation können Aktionen verbunden werden. + +sayHello :: IO () +sayHello = do + putStrLn "What is your name?" + name <- getLine -- eine Zeile wird geholt und + -- an die Variable "name" gebunden + putStrLn $ "Hello, " ++ name + +-- Uebung: Schreibe deine eigene Version von `interact`, +-- die nur eine Zeile einliest. + +-- `sayHello` wird niemals ausgefuehrt, nur `main` wird ausgefuehrt. +-- Um `sayHello` laufen zulassen kommentiere die Definition von `main` +-- aus und ersetze sie mit: +-- main = sayHello + +-- Lass uns untersuchen wie `getLine` arbeitet. +-- Der Typ ist: getLine :: IO String +-- Man kann sich vorstellen das der Wert vom Typ `IO a` ein +-- Programm repräsentiert das etwas vom Typ `a` generiert. +-- Der Wert wird mit `<-` gespeichert und kann wieder benutzt werden. +-- Wir könne auch eigene Funktionen vom Typ `IO String` definieren: + +action :: IO String +action = do + putStrLn "This is a line. Duh" + input1 <- getLine + input2 <- getLine + -- Der Typ von `do` ergibt sich aus der letzten Zeile. + -- `return` ist eine Funktion und keine Schluesselwort + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- Nun können wir `action` wie `getLine` benutzen: + +main'' = do + putStrLn "I will echo two lines!" + result <- action + putStrLn result + putStrLn "This was all, folks!" + +-- Der Typ `IO` ist ein Beispiel fuer eine Monade. +-- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit +-- eine rein funktional Sprache zu sein. +-- Jede Funktion die mit der Außenwelt interagiert (z.B. IO) +-- hat den Typ `IO` in seiner Signatur. +-- Damit kann man zwischen "reinen" Funktionen (interagieren nicht +-- mit der Außenwelt oder ändern ihren Zustand) und Anderen unterscheiden. + +-- Nebenläufigkeit ist in Haskell sehr einfach, da reine Funktionen +-- leicht nebenläufig arbeiten können. + +---------------------------------------------------- +-- 9. Die Haskell REPL +---------------------------------------------------- + +-- Starte die REPL mit dem Befehl `ghci` +-- Nun kann man Haskell Code eingeben. +-- Alle neuen Werte muessen mit `let` gebunden werden: + +let foo = 5 + +-- `:t` zeigt den Typen von jedem Wert an: + +>:t foo +foo :: Integer + +-- Auch jede `IO ()` Funktion kann ausgefuehrt werden. + +> sayHello +What is your name? +Friend! +Hello, Friend! + +``` + +Es gibt noch viel mehr in Haskell, wie zum Beispiel Typklassen und Monaden. +Dies sind die Ideen durch die Haskell Programmierung zum Spaß wird. +Mit dem folgenden kleinen Beispiel werde ich euch verlassen: +Quicksort in Haskell: + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Haskell ist sehr einfach zu installieren. +Hohl es dir von [hier](http://www.haskell.org/platform/). + +Eine sehr viele langsamere Einfuehrung findest du unter: +[Learn you a Haskell](http://learnyouahaskell.com/) oder +[Real World Haskell](http://book.realworldhaskell.org/). diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown new file mode 100644 index 00000000..f3917506 --- /dev/null +++ b/de-de/javascript-de.html.markdown @@ -0,0 +1,525 @@ +---
+language: javascript
+contributors:
+ - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+translators:
+ - ["ggb", "http://www.ideen-und-soehne.de"]
+filename: learnjavascript-de.js
+lang: de-de
+---
+
+(Anmerkungen des Original-Autors:)
+JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.
+
+Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.
+
+Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@adambrenecki](https://twitter.com/adambrenecki) oder [adam@brenecki.id.au](mailto:adam@brenecki.id.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).
+
+```js
+// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei
+// Slashes
+/* während mehrzeilige Kommentare mit einem
+Slash und einem Stern anfangen und enden */
+
+// Statements können mit einem Semikolon beendet werden
+machWas();
+
+// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn
+// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.
+machWas()
+
+// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist
+// es besser die Semikola immer zu setzen.
+
+///////////////////////////////////
+// 1. Nummern, Strings und Operationen
+
+// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).
+3; // = 3
+1.5; // = 1.5
+
+// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Division funktioniert auch mit einem Ergebnis nach dem Komma.
+5 / 2; // = 2.5
+
+// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation
+// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit
+// Vorzeichen) umgewandelt.
+1 << 2; // = 4
+
+// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.
+(1 + 3) * 2; // = 8
+
+// Es gibt drei spezielle, nicht-reale Nummern-Werte:
+Infinity; // Ergebnis von z. B. 1 / 0
+-Infinity; // Ergebnis von z. B. -1 / 0
+NaN; // Ergebnis von z. B. 0 / 0
+
+// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).
+true;
+false;
+
+// Strings werden mit ' oder " erzeugt.
+'abc';
+"Hello, world";
+
+// Für die Negation wird das ! benutzt.
+!true; // = false
+!false; // = true
+
+// Gleichheit wird mit === geprüft.
+1 === 1; // = true
+2 === 1; // = false
+
+// Ungleichheit wird mit !== überprüft.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Andere Vergleichsoperatoren sind
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings können mit + verbunden
+"Hello " + "world!"; // = "Hello world!"
+
+// und mit < und > verglichen werden.
+"a" < "b"; // = true
+
+// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...
+"5" == 5; // = true
+
+// ...solange man nicht === verwendet.
+"5" === 5; // = false
+
+// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode
+// 'charAt' zugegriffen werden
+"This is a string".charAt(0); // = "T"
+
+// Die Methode 'substring' gibt Teilbereiche eines Strings zurück
+"Hello world".substring(0, 5); // = "Hello"
+
+// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt
+"Hello".length; // = 5
+
+// Es gibt außerdem die Werte 'null' und 'undefined'
+null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen
+undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht
+ // verfügbar ist (obwohl genau genommen undefined selbst einen Wert
+ // darstellt)
+
+// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist
+// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".
+
+///////////////////////////////////
+// 2. Variablen, Arrays und Objekte
+
+// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren
+// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer
+// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.
+var einWert = 5;
+
+ // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler
+einAndererWert = 10;
+
+// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,
+// in dem sie erzeugt wurde.
+
+// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den
+// Wert 'undefined'.
+var einDritterWert; // = undefined
+
+// Es existiert eine Kurzform, um mathematische Operationen mit Variablen
+// auszuführen:
+einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10
+einWert *= 10; // einWert ist nach dieser Operation 100
+
+// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren
+// oder zu subtrahieren
+einWert++; // nun ist einWert 101
+einWert--; // wieder 100
+
+// Arrays sind geordnete Listen von Werten irgendeines Typs
+var myArray = ["Hello", 45, true];
+
+// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index
+// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung
+// beginnt bei 0.
+myArray[1]; // = 45
+
+// Arrays haben keine feste Länge
+myArray.push("World");
+myArray.length; // = 4
+
+// und sind veränderlich
+myArray[3] = "Hello";
+
+// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen
+// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.
+var myObj = { key1: "Hello", key2: "World" };
+
+// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt,
+// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von
+// jedem Typ sein.
+var myObj = { myKey: "myValue", "my other key": 4 };
+
+// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen
+// werden,
+myObj["my other key"]; // = 4
+
+// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt
+// sich bei dem Schlüssel um einen validen Bezeichner.
+myObj.myKey; // = "myValue"
+
+// Objekte sind veränderlich, Werte können verändert und neue Schlüssel
+// hinzugefügt werden.
+myObj.myThirdKey = true;
+
+// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein
+// undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Logik und Kontrollstrukturen
+
+// Die if-Struktur arbeitet, wie man es erwartet.
+var count = 1;
+if (count == 3){
+ // wird evaluiert, wenn count gleich 3 ist
+} else if (count == 4) {
+ // wird evaluiert, wenn count gleich 4 ist
+} else {
+ // wird evaluiert, wenn es weder 3 noch 4 ist
+}
+
+// Genauso 'while'.
+while (true) {
+ // Eine unendliche Schleife!
+}
+
+// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie
+// immer mindestens einmal ausgeführt werden.
+var input;
+do {
+ input = getInput();
+} while ( !isValid( input ) )
+
+// Die for-Schleife arbeitet genau wie in C und Java:
+// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird;
+// Iteration.
+for ( var i = 0; i < 5; i++ ) {
+ // wird 5-mal ausgeführt
+}
+
+// '&&' ist das logische und, '||' ist das logische oder
+if (house.size == "big" && house.colour == "blue"){
+ house.contains = "bear";
+ // Die Größe des Hauses ist groß und die Farbe blau.
+}
+if (colour == "red" || colour == "blue"){
+ // Die Farbe ist entweder rot oder blau.
+}
+
+// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die
+// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist
+// nützlich, um einen Default-Wert zu setzen.
+var name = otherName || "default";
+
+// Ein 'switch' Statement prüft Gleichheit mit ===
+// ohne ein 'break' nach jedem Fall
+// werden auch die Fälle nach dem korrekten aufgerufen
+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. Funktionen, Geltungsbereich und Closures
+
+// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.
+function myFunction(thing){
+ return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss
+// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht
+// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion
+// gibt 'undefined' zurück
+function myFunction()
+{
+ return // <- Hier wird automatisch ein Semikolon eingefügt
+ {
+ thisIsAn: 'object literal'
+ }
+}
+myFunction(); // = undefined
+
+// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie
+// Variablen verwendet und als Parameter anderen Funktionen übergeben werden
+// - zum Beispiel, um einen 'event handler' zu 'beliefern'.
+function myFunction() {
+ // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}
+setTimeout(myFunction, 5000);
+
+// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.
+// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument
+// einer anderen Funktion zu definieren.
+setTimeout(function(){
+ // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}, 5000);
+
+// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt:
+// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.
+if(true) {
+ var i = 5;
+}
+i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die
+ // ihren Geltungsbereich nach Blöcken richtet
+
+// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme
+// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen
+// 'verschmutzt' wird.
+(function(){
+ var temporary = 5;
+ // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden,
+ // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist
+ // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js,
+ // kann das anders aussehen).
+ window.permanent = 10;
+})();
+temporary; // wirft einen ReferenceError
+permanent; // = 10
+
+// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird
+// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die
+// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,
+// wenn die äußere Funktion beendet wurde.
+function sayHelloInFiveSeconds(name){
+ var prompt = "Hello, " + name + "!";
+ function inner(){
+ alert(prompt);
+ }
+ setTimeout(inner, 5000);
+ // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds
+ // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein'
+ // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere
+ // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die
+ // Variable prompt.
+}
+sayHelloInFiveSeconds("Adam"); // wird nach 5 Sekunden ein Popup mit der
+ // Nachricht "Hello, Adam!" öffnen.
+
+///////////////////////////////////
+// 5. Mehr über Objekte, Konstruktoren und Prototypen
+
+// Objekte können Funktionen enthalten.
+var myObj = {
+ myFunc: function(){
+ return "Hello world!";
+ }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie
+// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.
+myObj = {
+ myString: "Hello world!",
+ myFunc: function(){
+ return this.myString;
+ }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen
+// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht
+// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen
+// wird.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch
+// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem
+// Objekt nach dessen Definition zugewiesen wird.
+var myOtherFunc = function(){
+ return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs
+// verändert werden
+
+var anotherFunc = function(s){
+ return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente
+// aber in einem Array
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente
+// übergeben kann
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.
+// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird
+// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser
+// Art aufgerufen zu werden, werden Konstruktoren genannt.
+var MyConstructor = function(){
+ this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine
+// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,
+// schaut der Interpreter in dessen Prototyp nach.
+
+// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den
+// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das
+// nützlich ist, um Prototypen im Allgemeinen zu erklären, ist das nicht Teil
+// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir
+// später.
+var myObj = {
+ myString: "Hello world!",
+};
+var myPrototype = {
+ meaningOfLife: 42,
+ myFunc: function(){
+ return this.myString.toLowerCase()
+ }
+};
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Das funktioniert auch bei Funktionen.
+myObj.myFunc(); // = "hello world!"
+
+// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann
+// wird im Prototypen des Prototypen nachgesehen und so weiter.
+myPrototype.__proto__ = {
+ myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz
+// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann
+// werden die Änderungen überall sichtbar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es
+// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts
+// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem
+// gegebenen Prototypen erzeugt.
+
+// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des
+// JavaScript-Standards ist und daher noch nicht in allen Implementierungen
+// verfügbar.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun.
+// Konstruktoren haben eine Eigenschaft, die Prototyp heißt. Dabei handelt es
+// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt
+// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es
+// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.
+MyConstructor.prototype = {
+ getMyNumber: function(){
+ return this.myNumber
+ }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+
+// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren,
+// die zu dem Typ äquivalente Wrapper-Objekte erzeugen.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Genau genommen: Sie sind nicht exakt äquivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+ // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.
+}
+
+// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen
+// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen
+// hinzuzufügen.
+String.prototype.firstCharacter = function(){
+ return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'
+// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren
+// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in
+// älteren Umgebungen und Browsern verwendet werden können.
+
+// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in
+// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem
+// 'polyfill':
+if (Object.create === undefined){ // überschreib nichts, was eventuell bereits
+ // existiert
+ Object.create = function(proto){
+ // erstelle einen vorübergehenden Konstruktor mit dem richtigen
+ // Prototypen
+ var Constructor = function(){};
+ Constructor.prototype = proto;
+ // verwende es dann, um ein neues Objekt mit einem passenden
+ // Prototypen zurückzugeben
+ return new Constructor();
+ }
+}
+```
+
+## Zur weiteren Lektüre (englisch)
+
+Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.
+
+MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus.
+
+Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.
+
+Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.
diff --git a/de-de/json-de.html.markdown b/de-de/json-de.html.markdown new file mode 100644 index 00000000..3cf4578c --- /dev/null +++ b/de-de/json-de.html.markdown @@ -0,0 +1,65 @@ +--- +language: json +filename: learnjson-de.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Timm Albers", "https://github.com/nunull"] +lang: de-de +--- + +Da JSON ein äußerst einfaches Format für den Austausch von Daten ist, wird dieses +Dokument das vermutlich einfachste "Learn X in Y Minutes" werden. + +In seiner grundlegenden Form hat JSON keine eigentlichen Kommentare. Dennoch +akzeptieren die meisten Parser Kommentare in C-Syntax (`//`, `/* */`). Dennoch +soll für dieses Dokument nur 100% gültiges JSON verwendet werden, weshalbt keine +Kommentare verwendet werden. Glücklicherweise ist das nachfolgende Dokument +selbsterklärend. + +```json +{ + "schlüssel": "wert", + + "alle schlüssel": "müssen durch doppelte Anführungszeichen begrenzt werden", + "zahlen": 0, + "zeichenketten": "Alle Unicode-Zeichen (inklusive \"escaping\") sind erlaubt.", + "boolesche werte": true, + "nullwert": null, + + "große zahlen": 1.2e+100, + + "objekte": { + "kommentar": "Die meisten Datenstrukturen in JSON kommen aus Objekten.", + + "array": [0, 1, 2, "Arrays können Werte jeglichen Datentyps aufnehmen.", 4], + + "weiteres objekt": { + "kommentar": "Objekte können verschachtelt werden." + } + }, + + "quatsch": [ + { + "quellen von kalium": ["Bananen"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "Neo"], + [0, 0, 0, 1] + ] + ], + + "alternative formatierung": { + "kommentar": "..." + , "die position": "des Kommas ist nicht relevant - so lange es vor dem Wert steht." + , "weiterer kommentar": "wie schön" + , "übrigens": "Auch die Einrückung ist nicht relevant." + , "jede": "beliebige Anzahl von Leerzeichen / Tabs ist erlaubt.", "wirklich?":true + }, + + "das war kurz": "Und, du bist fertig. Du weißt nun (fast) alles über JSON." +} +``` diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown new file mode 100644 index 00000000..6a90980b --- /dev/null +++ b/de-de/markdown-de.html.markdown @@ -0,0 +1,256 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators : + - ["Frederik Ring", "https://github.com/m90"] + - ["Philipp Fischbeck", "https://github.com/PFischbeck"] +filename: markdown-de.md +lang: de-de +--- + +Markdown wurde im Jahr 2004 von John Gruber kreiert. Ziel ist und war eine +Syntax, in der sich Dokumente leicht schreiben *und* lesen lassen. Außerdem +sollte Markdown sich leicht nach HTML (und in andere Formate) konvertieren +lassen. + +```markdown +<!-- Markdown ist eine Obermenge von HTML - jede valide HTML-Datei ist also +automatisch valides Markdown - was heisst dass wir jedes HTML-Element (also auch +Kommentare) in Markdown benutzen können, ohne dass der Parser sie verändert. +Jedoch kann man innerhalb eines solchen HTML-Elements dann kein Markdown +mehr verwenden. --> + +<!-- Es existieren unterschiedliche Markdown-Parser und -Dialekte, die sich in +manchen Punkten unterscheiden. Diese Einführung wird versuchen, zu erläutern, +welche Features überall verfügbar sind, und welche davon parser-spezifisch sind --> + +<!-- Überschriften --> +<!-- HTML-Überschriften <h1> bis <h6> lassen sich einfach durch ein Voranstellen +der entsprechenden Anzahl an Hashes (#) auszeichnen --> +# Das ist eine <h1> +## Das ist eine <h2> +### Das ist eine <h3> +#### Das ist eine <h4> +##### Das ist eine <h5> +###### Das ist eine <h6> + +<!-- Für die Elemente <h1> und <h2> gibt es in Markdown noch Sonderformen --> +Das ist eine h1 +============= + +Das ist eine h2 +------------- + +<!-- Einfaches Textstyling --> +<!-- Jeglicher Text lässt sich mit Markdown leicht als kursiv oder +auch als fett auszeichnen --> + +*Dieser Text ist kursiv.* +_Genau wie dieser._ + +**Dieser Text ist fett.** +__Genau wie dieser.__ + +***Dieser Text ist beides*** +**_Dieser auch!_** +*__Und dieser genau so!__* + +<!-- In "Github Flavored Markdown", dem von Github verwendeten Dialekt / Parser, +gibt es auch noch durchgestrichenen Text: --> + +~~Dieser Text wird durchgestrichen dargestellt.~~ + +<!-- Absätze sind eine oder mehrere zusammenhängende Zeilen Text, und werden +durch eine oder mehrere Leerzeilen voneinander abgesetzt. --> + +Das ist ein Absatz. Ich kann immer noch nicht glauben, wie viel Spaß das macht !?! + +Jetzt bin ich schon bei Absatz 2. +Hier ist dann immer noch Absatz 2! + + +Jetzt ist das dann Nummer drei! + +<!-- Sollte man jemals ein <br />-Tag einfügen wollen, kann man einen Absatz +mit zwei oder mehr Leerzeichen beenden, und danach einen neuen Absatz beginnen. --> + +Ich höre mit zwei Leerzeichen auf (markiere mich, und du siehst es). + +Über mir ist wohl ein <br />! + +<!-- Zitate werden ganz einfach mit einem > ausgezeichnet. --> + +> Das ist ein Zitat. Du kannst Zeilenumbrüche +> entweder manuell hinzufügen und ein `>` vor jeder Zeile einfügen, oder du kannst deine Zeilen einfach immer länger und länger werden lassen, die Umbrüche werden dann automatisch erzeugt. +> Solange sie mit einem `>` beginnen, macht das keinen Unterschied. + +> Auch möglich ist es, den Text +>> mehrstufig einzurücken. +> Nicht schlecht, oder? + +<!-- Listen --> +<!-- <ul>s können mit Sternen, Pluszeichen oder Minuszeichen erzeugt werden --> + +* Punkt auf der Liste +* Punkt auf der Liste +* Anderer Punkt auf der Liste + +oder + ++ Punkt auf der Liste ++ Punkt auf der Liste ++ Noch ein Punkt auf der Liste + +oder + +- Punkt auf der Liste +- Punkt auf der Liste +- Ein letzter Punkt auf der Liste + +<!-- <ol>s werden mit einer Zahl gefolgt von einem Punkt erzeugt --> + +1. Punkt eins +2. Punkt zwei +3. Punkt drei + +<!-- Auch wenn es keine gute Idee sein mag: du müsstest die einzelnen Punkte +nicht mal korrekt numerieren --> + +1. Punkt eins +1. Punkt zwei +1. Punkt drei +<!-- (Das sieht genau so aus wie das Beispiel eins weiter oben) --> + +<!-- Man kann Listen auch verschachteln --> + +1. Punkt eins +2. Punkt zwei +3. Punkt drei + * Unterpunkt + * Unterpunkt +4. Punkt vier + +<!-- Code-Blöcke --> +<!-- Blöcke von Programmcode (also ein <code>-Element) kannst du auszeichnen, +indem du eine Zeile mit vier Leerzeichen oder einem Tabulator einrückst --> + + Das ist Quellcode + Das hier auch + +<!-- Der Code kann natürlich auch wiederum eingerückt sein --> + + my_array.each do |item| + puts item + end + +<!-- Innerhalb normalen Texts kannst du Code mit Backticks ` auszeichnen --> + +Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte! + +<!-- In "Github Flavored Markdown" gibt es für Code nocheinmal eine +besondere Syntax --> + +\`\`\`ruby <!-- in "echt" musst du die Backslashes entfernen: ```ruby ! --> +def foobar + puts "Hallo Welt!" +end +\`\`\` <!-- hier auch keine Backslashes, nur ``` --> + +<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt Github +Syntax-Highlighting für die nach dem ``` angegebene Sprache hinzu --> + +<!-- Horizontale Linie (<hr />) --> +<!-- Trenner lassen sich einfach mit drei (oder mehr) Sternen oder Bindestrichen +erzeugen (egal ob mit oder ohne Leerzeichen dazwischen)--> + +*** +--- +- - - +**************** + +<!-- Hyperlinks --> +<!-- Eines der besten Features von Markdown ist das kinderleichte Erzeugen von +Hyperlinks: Einfach den Linktext in eckige Klammern [] setzen, gefolgt von +einer mit runden Klammern () umschlossenen URL. --> + +[Klick mich!](http://test.de/) + +<!-- Man kann dem Link auch noch ein title-Attribut geben --> + +[Klick mich!](http://test.at/ "Link zu Test.at") + +<!-- Relative Pfade funktionieren natürlich auch --> + +[Zu meiner Musiksammlung](/music/). + +<!-- URLs lassen sich auch über Referenzen festlegen --> + +[Klick mich][link1], um mehr über mich herauszufinden! +[Hier kannst du auch mal draufklicken][foobar], wenn es dich interessiert. + +[link1]: http://test.de/ "Wahnsinn!" +[foobar]: http://foobar.ch/ "Erstaunlich!" + +<!-- Das title-Attribut wird entweder mit Anführungszeichen oder Klammern +umschlossen (oder gleich ganz weggelassen). Die Referenzen können an jeder +Stelle im gesamtem Dokument vorkommen, als ID kann alles verwendet werden, solange +es dokumentweit eindeutig ist. --> + +<!-- Man kann den Linktext auch als implizite Referenz benutzen --> + +[Das][] ist ein Link. + +[das]: http://dasisteinlink.at/ + +<!-- Das ist aber eher unüblich. --> + +<!-- Bilder --> +<!-- Bilder funktionieren genau wie Links, nur dass man noch ein Ausrufezeichen +voranstellt! --> + + + +<!-- Referenzen funktionieren auch hier genau wie erwartet --> + +![Das ist das alt-Attribut][meinbild] + +[meinbild]: relative/urls/gehen/auch.jpg "hier wäre noch Platz für einen title" + +<!-- Bonusfeatures --> +<!-- Auto-Links --> + +<http://testwebseite.de/> ist das selbe wie +[http://testwebseite.de/](http://testwebseite.de/) + +<!-- Automatische Links für E-Mail-Addressen --> + +<foo@bar.com> + +<!-- Maskieren --> + +Ich würde *diesen Teil gerne mit Sternen umschließen*, doch ohne dass er kursiv +wird. Also mache ich folgendes: \*Ich umschließe diesen Text mit Sternen\*! + +<!-- Tabellen --> +<!-- Tabellen gibt es bis jetzt nur in "Github Flavored Markdown". +Zudem sind sie ziemlich mühselig, aber wenn du es wirklich wissen willst: --> + +| Spalte1 | Spalte2 | Spalte3 | +| :----------- | :------: | ------------: | +| linksbündig | mittig | rechtsbündig | +| blah | blah | blah | + +<!-- oder das selbe in grün: --> + +Spalte1 | Spalte2 | Spalte3 +:-- | :-: | --: +Ganz schön hässlich | vielleicht doch lieber | wieder aufhören + +<!-- Das war's! --> + +``` + +Mehr Informationen gibt es in [John Gruber's offiziellem Blog-Post](http://daringfireball.net/projects/markdown/syntax) +und bei Adam Pritchards [grandiosem Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). +Infos zu Github Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
\ No newline at end of file diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown new file mode 100644 index 00000000..ae29d6f9 --- /dev/null +++ b/de-de/python-de.html.markdown @@ -0,0 +1,487 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["kultprok", "http:/www.kulturproktologie.de"] +filename: learnpython-de.py +lang: de-de +--- + +Anmerkungen des ursprünglichen Autors: +Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. + +Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service] + +Hinweis: Dieser Beitrag bezieht sich besonders auf Python 2.7, er sollte aber auf Python 2.x anwendbar sein. Haltet Ausschau nach einem Rundgang durch Python 3, der bald erscheinen soll. + +```python +# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) +""" Mehrzeilige Strings werden mit + drei '-Zeichen geschrieben und werden + oft als Kommentare genutzt. +""" + +#################################################### +## 1. Primitive Datentypen und Operatoren +#################################################### + +# Die Zahlen +3 #=> 3 + +# Mathematik funktioniert so, wie man das erwartet +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Division ist ein wenig kniffliger. Ganze Zahlen werden ohne Rest dividiert +# und das Ergebnis wird automatisch abgerundet. +5 / 2 #=> 2 + +# Um das zu ändern, müssen wir Gleitkommazahlen einführen und benutzen +2.0 # Das ist eine Gleitkommazahl +11.0 / 4.0 #=> 2.75 Ahhh...schon besser + +# Rangfolge wird mit Klammern erzwungen +(1 + 3) * 2 #=> 8 + +# Boolesche Ausdrücke sind primitive Datentypen +True +False + +# Mit not wird negiert +not True #=> False +not False #=> True + +# Gleichheit ist == +1 == 1 #=> True +2 == 1 #=> False + +# Ungleichheit ist != +1 != 1 #=> False +2 != 1 #=> True + +# Ein paar weitere Vergleiche +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Vergleiche können verknüpft werden! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Strings werden mit " oder ' gebildet +"Das ist ein String." +'Das ist auch ein String.' + +# Strings können addiert werden! +"Hello " + "world!" #=> "Hello world!" + +# Ein String kann wie eine Liste von Zeichen verwendet werden +"Das ist ein String"[0] #=> 'D' + +# Mit % können Strings formatiert werden, etwa so: +"%s können %s werden" % ("Strings", "interpoliert") + +# Ein modernerer Weg, um Strings zu formatieren, ist die format-Methode. +# Diese Methode wird bevorzugt +"{0} können {1} werden".format("Strings", "formatiert") +# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. +"{name} will {food} essen".format(name="Bob", food="Lasagne") + +# None ist ein Objekt +None #=> None + +# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen +# Benutzt stattdessen `is` +"etc" is None #=> False +None is None #=> True + +# Der 'is'-Operator testet Objektidentität. Das ist nicht +# sehr nützlich, wenn wir mit primitiven Datentypen arbeiten, aber +# sehr nützlich bei Objekten. + +# None, 0, und leere Strings/Listen werden alle als False bewertet. +# Alle anderen Werte sind True +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variablen und Collections +#################################################### + +# Textausgabe ist sehr einfach +print "Ich bin Python. Schön, dich kennenzulernen!" + + +# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. +some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm +some_var #=> 5 + +# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus. +# Unter "Kontrollstruktur" kann noch mehr über +# Ausnahmebehandlung erfahren werden. +some_other_var # Löst einen NameError aus + +# if kann als Ausdruck verwendet werden +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listen speichern Sequenzen +li = [] +# Wir können mit einer bereits gefüllten Liste anfangen +other_li = [4, 5, 6] + +# append fügt Daten am Ende der Liste ein +li.append(1) #li ist jetzt [1] +li.append(2) #li ist jetzt [1, 2] +li.append(4) #li ist jetzt [1, 2, 4] +li.append(3) #li ist jetzt [1, 2, 4, 3] +# Vom Ende der Liste mit pop entfernen +li.pop() #=> 3 und li ist jetzt [1, 2, 4] +# und dann wieder hinzufügen +li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. + +# Greife auf Listen wie auf Arrays zu +li[0] #=> 1 +# Das letzte Element ansehen +li[-1] #=> 3 + +# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError +li[4] # Raises an IndexError + +# Wir können uns Ranges mit Slice-Syntax ansehen +li[1:3] #=> [2, 4] +# Den Anfang auslassen +li[2:] #=> [4, 3] +# Das Ende auslassen +li[:3] #=> [1, 2, 4] + +# Ein bestimmtes Element mit del aus der Liste entfernen +del li[2] # li ist jetzt [1, 2, 3] + +# Listen können addiert werden +li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen + +# Listen mit extend verknüpfen +li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] + +# Mit in auf Existenz eines Elements prüfen +1 in li #=> True + +# Die Länge der Liste mit len ermitteln +len(li) #=> 6 + + +# Tupel sind wie Listen, nur unveränderlich. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Löst einen TypeError aus + +# Wir können all diese Listen-Dinge auch mit Tupeln anstellen +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Wir können Tupel (oder Listen) in Variablen entpacken +a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 +# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen +d, e, f = 4, 5, 6 +# Es ist kinderleicht zwei Werte zu tauschen +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionarys (Wörterbucher) speichern Key-Value-Paare +empty_dict = {} +# Hier ein gefülltes Wörterbuch +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Wir können Einträge mit [] nachschlagen +filled_dict["one"] #=> 1 + +# So holen wir alle Keys (Schlüssel) als Liste +filled_dict.keys() #=> ["three", "two", "one"] +# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. +# Einzelne Resultate können anders angeordnet sein. + +# Alle Values (Werte) als Liste +filled_dict.values() #=> [3, 2, 1] +# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. + +# Das Vorhandensein eines Schlüssels im Wörterbuch mit in prüfen +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus +filled_dict["four"] # KeyError + +# Mit der get-Methode verhindern wir das +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen +filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt +filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 + + +# Sets speichern Mengen +empty_set = set() +# Initialisieren wir ein Set mit ein paar Werten +some_set = set([1,2,2,3,4]) # some_set ist jetzt set([1, 2, 3, 4]) + +# Seit Python 2.7 kann {} benutzt werden, um ein Set zu erstellen +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Mehr Elemente hinzufügen +filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} + +# Schnittmengen werden mit & gebildet +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Mengen werden mit | vereinigt +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Die Differenz einer Menge mit - bilden +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Auf Vorhandensein von Elementen mit in prüfen +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Kontrollstruktur +#################################################### + +# Erstellen wir mal eine Variable +some_var = 5 + +# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! +# gibt "some_var ist kleiner als 10" aus +if some_var > 10: + print "some_var ist viel größer als 10." +elif some_var < 10: # Dieser elif-Absatz ist optional. + print "some_var ist kleiner als 10." +else: # Das hier ist auch optional. + print "some_var ist tatsächlich 10." + + +""" +For-Schleifen iterieren über Listen +Ausgabe: + hund ist ein Säugetier + katze ist ein Säugetier + maus ist ein Säugetier +""" +for animal in ["hund", "katze", "maus"]: + # Wir können Strings mit % formatieren + print "%s ist ein Säugetier" % animal + +""" +`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder +Ausgabe: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +While-Schleifen laufen, bis eine Bedingung erfüllt ist. +Ausgabe: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Kurzform für x = x + 1 + +# Ausnahmebehandlung mit einem try/except-Block + +# Funktioniert in Python 2.6 und höher: +try: + # Mit raise wird ein Fehler ausgegeben + raise IndexError("Das hier ist ein Index-Fehler") +except IndexError as e: + pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. + + +#################################################### +## 4. Funktionen +#################################################### + +# Mit def neue Funktionen erstellen +def add(x, y): + print "x ist %s und y ist %s" % (x, y) + return x + y # Werte werden mit return zurückgegeben + +# Funktionen mit Parametern aufrufen +add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück + +# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente +add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. + +# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Wir können auch Funktionen mit beliebiger Anzahl +# Schlüsselwort-Argumenten definieren +def keyword_args(**kwargs): + return kwargs + +# Rufen wir es mal auf, um zu sehen, was passiert +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Wir können beides gleichzeitig machem, wenn wir wollen +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) Ausgabe: + (1, 2) + {"a": 3, "b": 4} +""" + +# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! +# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) +all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) +all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) + +# Python hat First-Class-Funktionen +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Es gibt auch anonyme Funktionen +(lambda x: x > 2)(3) #=> True + +# Es gibt auch Funktionen höherer Ordnung als Built-Ins +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Klassen +#################################################### + +# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten. +class Human(object): + + # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt + species = "H. sapiens" + + # Ein simpler Konstruktor + def __init__(self, name): + # Wir weisen das Argument name dem name-Attribut der Instanz zu + self.name = name + + # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument. + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Eine Klassenmethode wird von allen Instanzen geteilt. + # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen + @classmethod + def get_species(cls): + return cls.species + + # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen + @staticmethod + def grunt(): + return "*grunt*" + + +# Eine Instanz einer Klasse erstellen +i = Human(name="Ian") +print i.say("hi") # gibt "Ian: hi" aus + +j = Human("Joel") +print j.say("hello") #gibt "Joel: hello" aus + +# Rufen wir mal unsere Klassenmethode auf +i.get_species() #=> "H. sapiens" + +# Ändern wir mal das gemeinsame Attribut +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Aufruf der statischen Methode +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Module +#################################################### + +# Wir können Module importieren +import math +print math.sqrt(16) #=> 4 + +# Wir können auch nur spezielle Funktionen eines Moduls importieren +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Wir können auch alle Funktionen eines Moduls importieren +# Warnung: Dies wird nicht empfohlen +from math import * + +# Wir können Modulnamen abkürzen +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Module sind in Python nur gewöhnliche Dateien. Wir +# können unsere eigenen schreiben und importieren. Der Name des +# Moduls ist der Dateiname. + +# Wir können auch die Funktionen und Attribute eines +# Moduls herausfinden. +import math +dir(math) + + +``` + +## Lust auf mehr? + +### Kostenlos online (Englisch) + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Totholz (Englisch) + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown new file mode 100644 index 00000000..19ea9e87 --- /dev/null +++ b/de-de/yaml-de.html.markdown @@ -0,0 +1,139 @@ +--- +language: yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +translators: + - ["Ruben M.", "https://github.com/switchhax"] +filename: learnyaml-de.yaml +lang: de-de +--- + +YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann. + +YAML ist eine Erweiterung von JSON, mit der Erweiterung von syntaktisch wichtigen Zeilenumbrüche und Einrückung sowie in Python. Anders als in Python erlaubt YAML keine Tabulator-Zeichen. + +```yaml +# Kommentare in YAML schauen so aus. + +################# +# SKALARE TYPEN # +################# + +# Unser Kernobjekt (für das ganze Dokument) wird das Assoziative Datenfeld (Map) sein, +# welches equivalent zu einem Hash oder einem Objekt einer anderen Sprache ist. +Schlüssel: Wert +nochn_Schlüssel: Hier kommt noch ein Wert hin. +eine_Zahl: 100 +wissenschaftliche_Notation: 1e+12 +boolean: true +null_Wert: null +Schlüssel mit Leerzeichen: value +# Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber: +jedoch: "Ein String in Anführungzeichen" +"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schluessel haben willst." + +# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text) +# oder ein 'folded block' (> gefolgt vom text). +literal_block: | + Dieser ganze Block an Text ist der Wert vom Schlüssel literal_block, + mit Erhaltung der Zeilenumbrüche. + + Das Literal fährt solange fort bis dieses unverbeult ist und die vorherschende Einrückung wird + gekürzt. + + Zeilen, die weiter eingerückt sind, behalten den Rest ihrer Einrückung - + diese Zeilen sind mit 4 Leerzeichen eingerückt. +folded_style: > + Dieser ganze Block an Text ist der Wert vom Schlüssel folded_style, aber diesmal + werden alle Zeilenumbrüche durch ein Leerzeichen ersetzt. + + Freie Zeilen, wie obendrüber, werden in einen Zeilenumbruch verwandelt. + + Weiter eingerückte Zeilen behalten ihre Zeilenumbrüche - + diese Textpassage wird auf zwei Zeilen sichtbar sein. + +#################### +# COLLECTION TYPEN # +#################### + +# Verschachtelung wird duch Einrückung erzielt. +eine_verschachtelte_map: + schlüssel: wert + nochn_Schlüssel: Noch ein Wert. + noch_eine_verschachtelte_map: + hallo: hallo + +# Schlüssel müssen nicht immer String sein. +0.25: ein Float-Wert als Schluessel + +# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels +? | + Dies ist ein Schlüssel, + der mehrzeilig ist. +: und dies ist sein Wert + +# YAML erlaubt auch Collections als Schlüssel, doch viele Programmiersprachen +# werden sich beklagen. + +# Folgen (equivalent zu Listen oder Arrays) schauen so aus: +eine_Folge: + - Artikel 1 + - Artikel 2 + - 0.5 # Folgen können verschiedene Typen enthalten. + - Artikel 4 + - schlüssel: wert + nochn_schlüssel: nochn_wert + - + - Dies ist eine Folge + - innerhalb einer Folge + +# Weil YAML eine Erweiterung von JSON ist, können JSON-ähnliche Maps und Folgen +# geschrieben werden: +json_map: {"schlüssel": "wert"} +json_seq: [3, 2, 1, "Start"] + +############################ +# EXTRA YAML EIGENSCHAFTEN # +############################ + +# YAML stellt zusätzlich Verankerung zu Verfügung, welche es einfach machen +# Inhalte im Dokument zu vervielfältigen. Beide Schlüssel werden den selben Wert haben. +verankerter_inhalt: &anker_name Dieser String wird als Wert beider Schlüssel erscheinen. +anderer_anker: *anker_name + +# YAML hat auch Tags, mit denen man explizit Typangaben angibt. +explicit_string: !!str 0.5 +# Manche Parser implementieren sprachspezifische Tags wie dieser hier für Pythons +# komplexe Zahlen. +python_komplexe_Zahlen: !!python/komplex 1+2j + +#################### +# EXTRA YAML TYPEN # +#################### + +# Strings and Zahlen sind nicht die einzigen Skalare, welche YAML versteht. +# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden. +DatumZeit: 2001-12-15T02:59:43.1Z +DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5 +Datum: 2002-12-14 + +# Der !!binary Tag zeigt das ein String base64 verschlüsselt ist. +# Representation des Binären Haufens +gif_datei: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML bietet auch Mengen (Sets), welche so ausschauen +menge: + ? artikel1 + ? artikel2 + ? artikel3 + +# Wie in Python sind Mengen nicht anderes als Maps nur mit null als Wert; das Beispiel oben drüber ist equivalent zu: +menge: + artikel1: null + artikel2: null + artikel3: null +``` diff --git a/el-gr/racket-gr.html.markdown b/el-gr/racket-gr.html.markdown new file mode 100644 index 00000000..4c4576bb --- /dev/null +++ b/el-gr/racket-gr.html.markdown @@ -0,0 +1,745 @@ +--- +language: racket +filename: learnracket-gr.rkt +contributors: + - ["th3rac25", "https://github.com/voila"] + - ["Eli Barzilay", "https://github.com/elibarzilay"] + - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"] + - ["Duong H. Nguyen", "https://github.com/cmpitg"] + - ["Keyan Zhang", "https://github.com/keyanzhang"] +translators: + - ["Vasilis Panagiotopoulos" , "https://github.com/billpcs/"] +lang: el-gr +--- + +H Racket είναι μια γενικού σκοπού, πολυ-υποδειγματική γλώσσα προγραμματισμού που ανήκει +στην οικογένεια της Lisp/Scheme + +```racket +#lang racket ; ορίζει την γλώσσα που χρησιμοποιόυμε + +;;; Σχόλια + +;; Τα σχόλια μιας γραμμής ξεκινούν με ερωτηματικό + +#| Τα σχόλια ολόκληρου μπλόκ + μπορούν να εκτείνονται σε πολλές γραμμές και... + #| + μπορούν να είναι εμφωλευμένα! + |# +|# + +;; Τα σχόλια S-expression (εκφράσεις S) comments απορρίπτουν την +;; έκφραση που ακολουθεί, δυνατότητα που είναι χρήσιμη για να +;; κάνουμε σχόλια κάποιες εκφράσεις κατα τη διάρκεια του debugging + +#; (αυτή η έκφραση δεν θα εκτελεστεί) + +;; (Αν δεν καταλαβαίνεται τι είναι οι εκφράσεις , περιμένετε... Θα το μάθουμε +;; πολύ συντομα!) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Πρωτογενείς τύποι μεταβλητών και τελεστές +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Αριθμοί +9999999999999999999999 ; ακέραιοι +#b111 ; δυαδικοί => 7 +#o111 ; οκταδικοί => 73 +#x111 ; δεκαεξαδικοί => 273 +3.14 ; πραγματικοί +6.02e+23 +1/2 ; ρητοί +1+2i ; μιγαδικοί + +;; Οι μορφή των συναρτήσεων είναι (f x y z) +;; όπου το f είναι η συνάρτηση και τα x y z +;; είναι οι όροι που η συνάρτηση δέχεται +;; ως ορίσματα. Αν θέλουμε να δημιουργήσουμε +;; μια λίστα στην κυριολεξία απο δίαφορα δεδομένα, +;; χρησιμοποιούμε το ' για να το εμποδίσουμε απο το να +;; αξιολογηθεί σαν έκφραση. Για παράδειγμα: +'(+ 1 2) ; => Παραμένει (+ 1 2) και δεν γίνεται η πράξη +;; Τώρα , ας κάνουμε μερικές πράξεις +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(quotient 5 2) ; => 2 +(remainder 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(exact->inexact 1/3) ; => 0.3333333333333333 +(+ 1+2i 2-3i) ; => 3-1i + +;;; Λογικές μεταβλητές +#t ; για το true (αληθής) +#f ; για το false (ψευδής) +(not #t) ; => #f +(and 0 #f (error "doesn't get here")) ; => #f +(or #f 0 (error "doesn't get here")) ; => 0 + +;;; Χαρακτήρες +#\A ; => #\A +#\λ ; => #\λ +#\u03BB ; => #\λ + +;;; Τα αλφαριθμητικά είναι πίνακες χαρακτήρων συγκεκριμένου μήκους +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; Το backslash είναι χαρακτήρας διαφυγής +"Foo\tbar\41\x21\u0021\a\r\n" ; Συμπεριλαμβάνονται οι χαρακτήες διαφυγής της C, + ; σε Unicode +"λx:(μα.α→α).xx" ; Μπορούν να υπάρχουν και Unicode χαρακτήρες + +;; Μπορούμε να εννώσουμε αλφαριθμητικά! +(string-append "Hello " "world!") ; => "Hello world!" + +;; Ένα αλφαριθμητικό μπορούμε να το χρησιμοπιησουμε +;; όπως και μια λίστα απο χαρακτήρες +(string-ref "Apple" 0) ; => #\A ;; Παίρνουμε το πρώτο στοιχείο + +;; Η συνάρτηση format μπορεί να χρησιμοποιηθεί για +;; να μορφοποιήσουμε αλφαριθμητικά +(format "~a can be ~a" "strings" "formatted") ;; => "strings can be formatted" + +;; Η εκτύπωση είναι εύκολη. +(printf "I'm Racket. Nice to meet you!\n") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Μεταβλητές +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Μπορούμε να δημιουργήσουμε μεταβλητές +;; χρησιμοποιώντας το define. +;; Ένα όνομα μεταβλητής μπορεί να χρησιμοποιεί οποιονδήποτε +;; χαρακτήρα, εκτός από τους: ()[]{}",'`;#|\ +(define some-var 5) +some-var ; => 5 + +;; Μπορούμε επίσης να χρησιμοποιήσουμε unicode χαρακτήρες. +(define ⊆ subset?) ;; Εδώ ουστιαστικά δίνουμε στη ήδη ύπαρχουσα συνάρτηση subset? + ;; ένα νέο όνομα ⊆ , και παρακάτω την καλούμε με το νέο της όνομα. +(⊆ (set 3 2) (set 1 2 3)) ; => #t + +;; Αν ζητήσουμε μια μεταβλητή που δεν έχει οριστεί πρίν π.χ +(printf name) +;; θα πάρουμε το παρακάτω μήνυμα +;name: undefined; +; cannot reference undefined identifier +; context...: + +;; Η τοπική δέσμευση : `me' δευσμεύεται με το "Bob" μόνο μέσα στο (let ...) +(let ([me "Bob"]) + "Alice" + me) ; => "Bob" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Δομές και συλλογές +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Δομές +(struct dog (name breed age)) +(define my-pet + (dog "lassie" "collie" 5)) +my-pet ; => #<dog> +(dog? my-pet) ; => #t +(dog-name my-pet) ; => "lassie" + +;;; Ζεύγη (αμετάβλητα) +;; Η δεσμευμένη λέξη `cons' δημιουργεί ζεύγη, +;; και το `car' και το `cdr' εξάγουν το πρώτο και +;; το δεύτερο στοιχείο αντίστοιχα. +(cons 1 2) ; => '(1 . 2) +(car (cons 1 2)) ; => 1 +(cdr (cons 1 2)) ; => 2 + +;;; Λίστες + +;; Οι λίστες είναι linked-list δομές δεδομένων, +;; που έχουν δημιουργηθεί απο ζευγάρια 'cons' +;; και τελειώνουν με 'null' (ή αλλιώς '()) για να +;; δηλώσουν ότι αυτό είναι το τέλος της λίστας +(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3) +;; Η δεσμευμένη λέξη 'list' είναι ένας εναλλακτικός +;; (και σαφώς πιο βολικός) τρόπος για να δημιουργούμε +;; λίστες +(list 1 2 3) ; => '(1 2 3) +;; αλλά και χρησιμοποιώντας ένα μονό εισαγωγικό το +;; το αποτέλεσμα είναι και πάλι το ίδιο +'(1 2 3) ; => '(1 2 3) + +;; Μπορούμε και πάλι όμως να χρησιμοποιούμε το 'cons' για να +;; προσθέσουμε ένα στοιχείο στην αρχή της λίστας +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; Μπορούμε να χρησιμοποιούμε το 'append' για να προσθέτουμε +;; στοιχεία στο τέλος μιας λίστας. Το στοιχείο αυτό μπορεί +;; και να είναι ολόκληρη λίστα! +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; Οι λίστες στην Racket είναι πολύ βασικές , οπότε υπάρχουν πολλές +;; δυνατές λειτουργίες για αυτές. Παρακάτω είναι μερικά παραδείγματα: +(map add1 '(1 2 3)) ; => '(2 3 4) +(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(filter even? '(1 2 3 4)) ; => '(2 4) +(count even? '(1 2 3 4)) ; => 2 +(take '(1 2 3 4) 2) ; => '(1 2) +(drop '(1 2 3 4) 2) ; => '(3 4) + +;;; Διανύσματα + +;; Τα διανύσματα είναι πίνακες σταθερού μήκους +#(1 2 3) ; => '#(1 2 3) + +;; Χρησιμοποιύμε το `vector-append' για να προσθέσουμε διανύσματα +(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Σύνολα + +;; Δημιουργούμε ένα σύνολο απο μία λίστα +(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3) + +;; Προσθέτουμε έναν αριθμό στο σύνολο χρησιμοποιώντας το `set-add' +(set-add (set 1 2 3) 4) ; => (set 1 2 3 4) + +;; Αφαιρούμε με το `set-remove' +(set-remove (set 1 2 3) 1) ; => (set 2 3) + +;; Βλέπουμε αν υπάρχει ένας αριθμός στο σύνολο με το `set-member?' +(set-member? (set 1 2 3) 1) ; => #t +(set-member? (set 1 2 3) 4) ; => #f + +;;; Πίνακες κατακερματισμού (Hashes) + +;; Δημιουργήστε ένα αμετάβλητο πίνακα κατακερματισμού +(define m (hash 'a 1 'b 2 'c 3)) + +;; Παίρνουμε μια τιμή απο τον πίνακα +(hash-ref m 'a) ; => 1 + +;; Άν ζητήσουμε μια τιμή που δέν υπάρχει παίρνουμε μία εξαίρεση +; (hash-ref m 'd) => no value found for key + +;; Μπορούμε να δώσουμε μια default τιμή για τα κλειδιά που λείπουν +(hash-ref m 'd 0) ; => 0 + + +;; Χρησιμοποιούμε το 'hash-set' για να επεκτείνουμε +;; ένα πίνακα κατακερματισμού +(define m2 (hash-set m 'd 4)) +m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3)) + +;; Θυμηθείτε ! Αυτοί οι πίνακες κατακερματισμού +;; είναι αμετάβλητοι! +m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- δεν υπάρχει `d' + +;; Χρησιμοποιούμε το `hash-remove' για να αφαιρέσουμε +;; κλειδία +(hash-remove m 'a) ; => '#hash((b . 2) (c . 3)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Συναρτήσεις +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Χρησιμοποιούμε το `lambda' για να δημιουργήσουμε συναρτήσεις. +;; Μια συνάρτηση πάντα επιστρέφει την τιμή της τελευταίας της έκφρασης +(lambda () "Hello World") ; => #<procedure> +;; Μπορούμε επίσης να χρησιμοποιήσουμε το `λ' +(λ () "Hello World") ; => Ίδια συνάρτηση + +;; Χρησιμοποιύμε τις παρενθέσεις για να καλέσουμε όλες τις συναρτήσεις +;; συμπεριλαμβανομένων και των εκφράσεων 'λάμδα' +((lambda () "Hello World")) ; => "Hello World" +((λ () "Hello World")) ; => "Hello World" + +;; Εκχωρούμε σε μια μετάβλητη την συνάρτηση +(define hello-world (lambda () "Hello World")) +(hello-world) ; => "Hello World" + +;; Μπορούμε αυτό να το κάνουμε συντομότερο χρησιμοποιώντας +;; το λεγόμενο syntactic sugar : +(define (hello-world2) "Hello World") + +;; Το () στο παραπάνω είναι η λίστα από τα ορίσματα για την συνάρτηση + +(define hello + (lambda (name) + (string-append "Hello " name))) +(hello "Steve") ; => "Hello Steve" +;; ... ή ισοδύναμα, χρησιμοποιώντας sugared ορισμό: +(define (hello2 name) + (string-append "Hello " name)) + +;; Μπορούμε να έχουμε συναρτήσεις με πολλές μεταβλητές χρησιμοποιώντας +;; το `case-lambda' +(define hello3 + (case-lambda + [() "Hello World"] + [(name) (string-append "Hello " name)])) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" +;; ... ή να ορίσουμε προαιρετικά ορίσματα με μια έκφραση προκαθορισμένης τιμής +(define (hello4 [name "World"]) + (string-append "Hello " name)) + +;; Οι συναρτήσεις μπορούν να πακετάρουν επιπλέον +;; ορίσματα μέσα σε μια λίστα +(define (count-args . args) + (format "You passed ~a args: ~a" (length args) args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" +;; ... ή με unsugared μορφή `lambda': +(define count-args2 + (lambda args + (format "You passed ~a args: ~a" (length args) args))) + +;; Μπορούμε να εμπλέξουμε κανονικά και πακεταρισμένα ορίσματα +(define (hello-count name . args) + (format "Hello ~a, you passed ~a extra args" name (length args))) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" +;; ... και unsugared: +(define hello-count2 + (lambda (name . args) + (format "Hello ~a, you passed ~a extra args" name (length args)))) + +;; Και με λέξεις κλειδία +(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args) + (format "~a ~a, ~a extra args" g name (length args))) +(hello-k) ; => "Hello World, 0 extra args" +(hello-k 1 2 3) ; => "Hello World, 3 extra args" +(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args" +(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args" +(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6) + ; => "Hi Finn, 6 extra args" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Ισότητα +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; για αριθμούς χρησιμοποιούμε το `=' +(= 3 3.0) ; => #t +(= 2 1) ; => #f + +;; Το `eq?' επιστρέφει #t αν δύο 2 ορίσματα αναφέρονται στο +;; ίδιο αντικείμενο (στη μνήμη),αλλιώς επιστρέφει #f. +;; Με άλλα λόγια, είναι απλή σύγκριση δεικτών. +(eq? '() '()) ; => #t, αφού υπάρχει μόνο μια άδεια λίστα στη μνήμη +(let ([x '()] [y '()]) + (eq? x y)) ; => #t, το ίδιο με πάνω + +(eq? (list 3) (list 3)) ; => #f +(let ([x (list 3)] [y (list 3)]) + (eq? x y)) ; => #f — δεν είναι η ίδια λίστα στην μνήμη! + +(let* ([x (list 3)] [y x]) + (eq? x y)) ; => #t, Αφού το x και το y τώρα δείχνουν στην ίδια θέση + +(eq? 'yes 'yes) ; => #t +(eq? 'yes 'no) ; => #f + +(eq? 3 3) ; => #t — να είστε προσεκτικοί εδώ + ; Είναι προτιμότερο να χρησιμοποιείτε `=' για την + ; σύγκριση αριθμών. +(eq? 3 3.0) ; => #f + +(eq? (expt 2 100) (expt 2 100)) ; => #f +(eq? (integer->char 955) (integer->char 955)) ; => #f + +(eq? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f + +;; Το `eqv?' υποστηρίζει την σύκριση αριθμών αλλα και χαρακτήρων +;; Για άλλα ήδη μεταβλητών το `eqv?' και το `eq?' επιστρέφουν το ίδιο. +(eqv? 3 3.0) ; => #f +(eqv? (expt 2 100) (expt 2 100)) ; => #t +(eqv? (integer->char 955) (integer->char 955)) ; => #t + +(eqv? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f + +;; Το `equal?' υποστηρίζει την σύγκριση των παρακάτω τύπων μεταβλητών: +;; αλφαριθμητικά, αλφαριθμητικά από bytes, μεταβλητά ζεύγη , διανύσματα, +;; πίνακες κατακερματισμού και δομές. +;; Για άλλα ήδη τύπων μεταβλητών το `equal?' και το `eqv?' επιστρέφουν το +;; ίδιο αποτέλεσμα. +(equal? 3 3.0) ; => #f +(equal? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #t +(equal? (list 3) (list 3)) ; => #t + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Έλεχγος Ροής +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Συνθήκες (conditionals) + +(if #t ; έκφραση ελέχγου + "this is true" ; έκφραση then + "this is false") ; έκφραση else +; => "this is true" + + +;; Στα conditionals, όλες οι μη #f τιμές θεωρούνται ως #t +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'yep + +;; Οι αλυσίδες `cond' είναι σειρές από ελέγχους για να +;; επιλεγεί ένα αποτέλεσμα +(cond [(> 2 2) (error "wrong!")] + [(< 2 2) (error "wrong again!")] + [else 'ok]) ; => 'ok + +;;; Αντιστοίχιση μοτίβων + +(define (fizzbuzz? n) + (match (list (remainder n 3) (remainder n 5)) + [(list 0 0) 'fizzbuzz] + [(list 0 _) 'fizz] + [(list _ 0) 'buzz] + [_ #f])) + +(fizzbuzz? 15) ; => 'fizzbuzz +(fizzbuzz? 37) ; => #f + +;;; Βρόχοι + +;; Οι επαναλήψεις μπορούν να γίνουν μέσω αναδρομής +(define (loop i) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) +(loop 5) ; => i=5, i=6, ... + +;; Παρομοίως με τη χρήση 'let' +(let loop ((i 0)) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) ; => i=0, i=1, ... + + +;; Θα δείτε παρακάτω πως να προσθέσουμε μια νέα μορφή επανάληψης +;; αλλά η Racket έχει ήδη πολύ ευέλικτη μορφή για τους βρόχους +(for ([i 10]) + (printf "i=~a\n" i)) ; => i=0, i=1, ... +(for ([i (in-range 5 10)]) + (printf "i=~a\n" i)) ; => i=5, i=6, ... + +;;; +;;; Επανάληψη μέσα σε ακολουθίες: +;; Το `for' επιτρέπει την επανάληψη μέσα σε πολλά +;; άλλα ήδη από ακολουθίες: Λίστες, διανύσματα, +;; αλφαριθμητικά, σύνολα κτλ.. + +(for ([i (in-list '(l i s t))]) + (displayln i)) + +(for ([i (in-vector #(v e c t o r))]) + (displayln i)) + +(for ([i (in-string "string")]) + (displayln i)) + +(for ([i (in-set (set 'x 'y 'z))]) + (displayln i)) + +(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))]) + (printf "key:~a value:~a\n" k v)) + +;;; Πιο περίπλοκες επαναλήψεις + +;; Παράλληλη σάρωση σε πολλαπλές ακολουθίες +;; (σταματά στην πιο σύντομη) +(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x 1:y 2:z + +;; Εμφολευμένοι βρόχοι +(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z + +;; Συνθήκες +(for ([i 1000] + #:when (> i 5) + #:unless (odd? i) + #:break (> i 10)) + (printf "i=~a\n" i)) +; => i=6, i=8, i=10 + +;;; Σάρωση σε λίστες +;; Παρόμοιο με τους βρόχους 'for', απλά συλλέγουμε τα αποτελέσματα + +(for/list ([i '(1 2 3)]) + (add1 i)) ; => '(2 3 4) + +(for/list ([i '(1 2 3)] #:when (even? i)) + i) ; => '(2) + +(for/list ([i 10] [j '(x y z)]) + (list i j)) ; => '((0 x) (1 y) (2 z)) + +(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10)) + i) ; => '(6 8 10) + +(for/hash ([i '(1 2 3)]) + (values i (number->string i))) +; => '#hash((1 . "1") (2 . "2") (3 . "3")) + +;; Υπάρχουν πολλά είδη απο προϋπάρχοντες τρόπους για να συλλέγουμε +;; τιμές από τους βρόχους + +(for/sum ([i 10]) (* i i)) ; => 285 +(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 +(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t +(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t + +;; Και για να χρησιμοποιήσουμε ένα αφθαίρετο συνδιασμό χρησιμοποιούμε +;; το 'for/fold' +(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10 + +;; Αυτό συχνά μπορεί να αντικαταστήσει τους κοινούς +;; προστακτικούς βρόχους (imperative loops) + +;;; Εξαιρέσεις + +;; Για να πιάσουμε τις εξαιρέσεις χρησιμοποιούμε το +;; `with-handlers' +(with-handlers ([exn:fail? (lambda (exn) 999)]) + (+ 1 "2")) ; => 999 +(with-handlers ([exn:break? (lambda (exn) "no time")]) + (sleep 3) + "phew") ; => "phew", αλλά αν γίνει το break => "no time" + +;; Χρησιμοποιούμε το 'raise' για να άρουμε μια εξαίρεση +;; ή οποιαδήποτε άλλη τιμή +(with-handlers ([number? ; πιάνουμε αριθμητικές τιμές + identity]) ; και τις επιστρέφουμε σαν απλές τιμές + (+ 1 (raise 2))) ; => 2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Αλλαγή τιμών +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Χρησιμοποιούμε το 'set!' για να θέσουμε μια νέα τιμή +;; σε μια ήδη υπάρχουσα μεταβλητή +(define n 5) +(set! n (add1 n)) +n ; => 6 + +;; Χρησιμοποιούμε τα boxes για να δηλώσουμε ρητά ότι μια μεταβητή +;; θα είναι mutable (θα μπορεί να αλλάξη η τιμή της) +;; Αυτό είναι παρόμοιο με τους pointers σε άλλες γλώσσες +(define n* (box 5)) +(set-box! n* (add1 (unbox n*))) +(unbox n*) ; => 6 + + +;; Πολλοί τύποι μεταβλητών στη Racket είναι αμετάβλητοι πχ τα ζεύγη, οι +;; λίστες κτλ. Άλλοι υπάρχουν και σε μεταβλητή και σε αμετάβλητη μορφή +;; πχ αλφαριθμητικά, διανύσματα κτλ +(define vec (vector 2 2 3 4)) +(define wall (make-vector 100 'bottle-of-beer)) +;; Χρησιμοποιούμε το 'vector-set!' για να ανεώσουμε κάποια +;; συγκεκριμένη θέση +(vector-set! vec 0 1) +(vector-set! wall 99 'down) +vec ; => #(1 2 3 4) + + +;; Έτσι δημιουργούμε ένα άδειο μεταβλητό πίνακα κατακερματισμού +;; και τον χειριζόμαστε κατάλληλα +(define m3 (make-hash)) +(hash-set! m3 'a 1) +(hash-set! m3 'b 2) +(hash-set! m3 'c 3) +(hash-ref m3 'a) ; => 1 +(hash-ref m3 'd 0) ; => 0 +(hash-remove! m3 'a) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Ενότητες (modules) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + +;; Οι ενότητες μας επιτρέπουν να οργανώνουμε τον κώδικα σε πολλαπλά +;; αρχεία και επαναχρησιμοποιούμενες βιβλιοθήκες +;; Εδώ χρησιμοποιούμε υπο-ενότητες, εμφωλευμένες μέσα σε μια +;; άλλη ενότητα που δημιουργεί αυτό το κείμενο (ξεκινώντας από +;; την γραμμή '#lang' ) +(module cake racket/base ; ορίζουμε μια ενότητα 'cake' βασισμένο στο + ; racket/base + + (provide print-cake) ; συνάρτηση που εξάγεται από την ενότητα + + (define (print-cake n) + (show " ~a " n #\.) + (show " .-~a-. " n #\|) + (show " | ~a | " n #\space) + (show "---~a---" n #\-)) + + (define (show fmt n ch) ; εσωτερική συνάρτηση + (printf fmt (make-string n ch)) + (newline))) + +;; Χρησιμοποιομε το 'require' για να πάρουμε όλα τα +;; παρεχόμενα ονόματα από μία ενότητα +(require 'cake) ; το ' είναι για τοπική υποενότητα +(print-cake 3) +; (show "~a" 1 #\A) ; => error, το `show' δεν έχει εξαχθεί + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. Κλάσεις και αντικείμενα +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Δημιουργούμε μια κλάση fish% (- συνήθως χρησιμοποιούμε +;; το % στο όνομα μιας κλάσης ) +(define fish% + (class object% + (init size) ; initialization argument + (super-new) ; superclass initialization + ;; Field + (define current-size size) + ;; Public methods + (define/public (get-size) + current-size) + (define/public (grow amt) + (set! current-size (+ amt current-size))) + (define/public (eat other-fish) + (grow (send other-fish get-size))))) + +;; Δημιουργούμε ένα instance του fish% +(define charlie + (new fish% [size 10])) + +;; Χρησιμοποιούμε το 'send' για να καλέσουμε +;; τις μεθόδους ενός αντικειμένου +(send charlie get-size) ; => 10 +(send charlie grow 6) +(send charlie get-size) ; => 16 + +;; Το `fish%' είναι μία τιμή "πρώτης κλάσης" +;; με το οποίο μπορούμε να κάνουμε προσμείξεις +(define (add-color c%) + (class c% + (init color) + (super-new) + (define my-color color) + (define/public (get-color) my-color))) +(define colored-fish% (add-color fish%)) +(define charlie2 (new colored-fish% [size 10] [color 'red])) +(send charlie2 get-color) +;; ή χωρίς καθόλου ονόματα : +(send (new (add-color fish%) [size 10] [color 'red]) get-color) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 9. Μακροεντολές +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Οι μακροεντολές μας επιτρέπουν να επεκτείνουμε +;; το συντακτικό μιάς γλώσσας. + +;; Ας προσθέσουμε έναν βρόχο while +(define-syntax-rule (while condition body ...) + (let loop () + (when condition + body ... + (loop)))) + +(let ([i 0]) + (while (< i 10) + (displayln i) + (set! i (add1 i)))) + +;; Macros are hygienic, you cannot clobber existing variables! +(define-syntax-rule (swap! x y) ; -! is idiomatic for mutation + (let ([tmp x]) + (set! x y) + (set! y tmp))) + +(define tmp 2) +(define other 3) +(swap! tmp other) +(printf "tmp = ~a; other = ~a\n" tmp other) +;; Η μεταβλητή 'tmp' μετονομάζεται σε 'tmp_1' +;; για να αποφευχθεί η σύγκρουση με τα ονόματα +;; (let ([tmp_1 tmp]) +;; (set! tmp other) +;; (set! other tmp_1)) + +;; Αλλά ακόμα υπάρχουν ακόμη μετασχηματισμοί του κώδικα, π.χ: +(define-syntax-rule (bad-while condition body ...) + (when condition + body ... + (bad-while condition body ...))) +;; αυτή η μακροεντολή είναι χαλασμένη: δημιουγεί ατέρμονα βρόχο +;; και αν προσπαθήσουμε να το χρησιμοποιήσουμε, ο μεταγλωττιστής +;; θα μπεί στον ατέρμονα βρόχο. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 10. Συμβόλαια (Contracts) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Τα συμβόλαια βάζουν περιορισμόυς σε τιμές που προέρχονται +;; από ενότητες (modules) +(module bank-account racket + (provide (contract-out + [deposit (-> positive? any)] ; οι ποσότητες είναι πάντα θετικές + [balance (-> positive?)])) + + (define amount 0) + (define (deposit a) (set! amount (+ amount a))) + (define (balance) amount) + ) + +(require 'bank-account) +(deposit 5) + +(balance) ; => 5 + +;; Πελάτες που προσπαθούν να καταθέσουν ένα μη θετικό ποσό παίρνουν +;; το μήνυμα (deposit -5) ; => deposit: contract violation +;; expected: positive? +;; given: -5 +;; more details.... + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 11. Είσοδος και έξοδος +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Η Racket έχει την έννοια του "port", που είναι παρόμοιο με τα +;; file descriptors σε άλλες γλώσσες. + +;; Ανοίγουμε το "/tmp/tmp.txt" και γράφουμε μέσα "Hello World" +;; Αυτό θα προκαλούσε σφάλμα αν το αρχείο υπήρχε ήδη +(define out-port (open-output-file "/tmp/tmp.txt")) +(displayln "Hello World" out-port) +(close-output-port out-port) + +;; Προσθέτουμε στο τέλος του "/tmp/tmp.txt" +(define out-port (open-output-file "/tmp/tmp.txt" + #:exists 'append)) +(displayln "Hola mundo" out-port) +(close-output-port out-port) + +;; Διαβάζουμε απο αρχείο ξανά +(define in-port (open-input-file "/tmp/tmp.txt")) +(displayln (read-line in-port)) +; => "Hello World" +(displayln (read-line in-port)) +; => "Hola mundo" +(close-input-port in-port) + +;; Εναλλακτικά, με το call-with-output-file δεν χρειάζεται να κλείσουμε +;; ρητά το αρχείο +(call-with-output-file "/tmp/tmp.txt" + #:exists 'update ; Rewrite the content + (λ (out-port) + (displayln "World Hello!" out-port))) + +;; Και το call-with-input-file κάνει το ίδιο πράγμα για την είσοδο +(call-with-input-file "/tmp/tmp.txt" + (λ (in-port) + (displayln (read-line in-port)))) +``` + +## Επιπλέον πηγές + +Ψάχνεις για περισσότερα ; [Getting Started with Racket](http://docs.racket-lang.org/getting-started/) diff --git a/el-gr/scala-gr.html.markdown b/el-gr/scala-gr.html.markdown new file mode 100644 index 00000000..e29c7e70 --- /dev/null +++ b/el-gr/scala-gr.html.markdown @@ -0,0 +1,689 @@ +--- +language: Scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra", "http://dbousamra.github.com"] + - ["Geoff Liu", "http://geoffliu.me"] +translators: + - ["Vasilis Panagiotopoulos" , "https://github.com/billpcs/"] +filename: learnscala-gr.scala +lang: el-gr +--- + +Scala - Η επεκτάσιμη γλώσσα + +```scala + +/* + Προετοιμαστείτε: + + 1) Κατεβάστε την Scala - http://www.scala-lang.org/downloads + 2) Κάνετε εξαγωγή στην επιθυμητή σας τοποθεσία και βάλτε τον υποφάκελο bin + στο path του συστήματος + 3) Ξεκινήστε ένα scala REPL γράφοντας scala. Θα πρέπει να βλέπετε το prompt: + + scala> + + Αυτό είναι το αποκαλούμενο REPL (Read-Eval-Print Loop) *. + Μπορείτε να πληκτρολογήσετε οποιαδήποτε έγκυρη έκφραση σε Scala μέσα του , + και το αποτέλεσμα θα τυπωθεί. Θα εξηγήσουμε πως μοιάζουν τα αρχεία της Scala + αργότερα μέσα στο tutorial , αλλά για τώρα ας αρχίσουμε με κάποια βασικά. + *[Βρόχος του Διάβασε - Αξιολόγησε - Τύπωσε] +*/ + + +///////////////////////////////////////////////// +// 1. Βασικές έννοιες +///////////////////////////////////////////////// + +// Τα σχόλια μίας γραμμής ξεκινούν με δύο "/" (:forward slashes) . + +/* + Τα σχόλια που επεκτείνονται σε πολλές γραμμές , όπως μπορείτε + να δείτε , φαίνοται κάπως έτσι. +*/ + +// Εκτύπωση με νέα γραμμή στην επόμενη εκτύπωση +println("Hello world!") +println(10) + +// Εκτύπωση χωρίς νέα γραμμή στην επόμενη εκτύπωση +print("Hello world") + +// Η δήλωση μεταβλητών γίνεται χρησιμοποιώντας var ή val. +// Οι δηλώσεις val είναι αμετάβλητες, ενώ οι var είναι μεταβλητές. +// Η αμεταβλητότητα είναι συμφέρουσα και προσπαθούμε να την χρησιμοποιούμε. +val x = 10 // το x είναι τώρα 10 +x = 20 // σφάλμα: αλλαγή σε val +var y = 10 +y = 20 // το y είναι τώρα 20 + +/* + Η Scala είναι στατικού τύπου γλώσσα, εν τούτις προσέξτε ότι στις παραπάνω + δηλώσεις , δεν προσδιορίσαμε κάποιον τύπο. Αυτό συμβαίνει λόγω ενός + χαρακτηριστικού της Scala που λέγεται συμπερασματολογία τύπων. Στις + περισσότερες των περιπτώσεων, ο μεταγλωττιστής της Scala μπορεί να + μαντέψει ποιός είναι ο τύπος μιας μεταβλητής. Μπορούμε να δηλώσουμε + αναλυτικά τον τύπο μιάς μεταβλητής ως εξής: +*/ +val z: Int = 10 +val a: Double = 1.0 + +/* + Προσέξτε ότι υπάρχει αυτόματη μετατροπή από ακέραιο (Int) σε διπλής + ακρίβειας (Double), και συνεπώς το αποτέλεσμα είναι 10.0 και όχι 10. +*/ +val b: Double = 10 + +// Λογικές τιμές +true +false + +// Λογικές Πράξεις +!true // false +!false // true +true == false // false +10 > 5 // true + +// Η αριθμιτική είναι όπως τα συνηθισμένα +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 +6 / 4 // 1 +6.0 / 4 // 1.5 + + +/* + Αξιολογώντας μια έκφραση στο REPL, σας δίνεται ο τύπος και + η τιμή του αποτελέσματος +*/ + +1 + 7 + +/* Η παραπάνω γραμμή έχει το εξής αποτέλεσμα: + + scala> 1 + 7 + res29: Int = 8 + + Αυτό σημαίνει ότι το αποτέλεσμα της αξιολόγησης του 1 + 7 είναι ένα αντικείμενο + τύπου Int με τιμή 8 + + Σημειώστε ότι το "res29" είναι ένα σειριακά δημιουργούμενο όνομα μεταβλητής + για να αποθηκεύονται τα αποτελέσματα των εκφράσεων που έχετε πληκτρολογήσει + και συνεπώς η έξοδός σας μπορεί να διαφέρει. +*/ + +"Τα αλφαριθμητικά στην Scala περικλείονται από διπλά εισαγωγικά" +'a' // Ένας χαρακτήρας στην Scala +// res30: Char = a +// 'Αλφαριθημτικά με μονά εισαγωγικά δεν υφίστανται <= Αυτό θα προκαλέσει σφάλμα. + +// Τα αλφαριθμητικά έχουν τις συνηθισμένες μεθόδους της Java ορισμένες πάνω τους. +"hello world".length +"hello world".substring(2, 6) +"hello world".replace("C", "3") + +// Έχουν επίσης μερικές επιπλένον μεθόδους Scala. +// Δείτε επίσης : scala.collection.immutable.StringOps +"hello world".take(5) +"hello world".drop(5) + +// Παρεμβολή αλφαριθμητικών : παρατηρήστε το πρόθεμα "s" +val n = 45 +s"We have $n apples" // => "We have 45 apples" + +// Παρατηρήστε την χρήση των '{', '}' +val a = Array(11, 9, 6) +s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old." +s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples." +s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" + +// Μορφοποίηση με παρεμβεβλημένα αλφαριθμητικά με το πρόθεμα "f" +f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" +f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" + +// Raw αλφαριθμητικά, που αγνοούν τους ειδικούς χαρακτήρες. +raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." + +// Μερικούς χαρακτήρες πρέπει να τους κάνουμε "escape", +// λ.χ ένα διπλό εισαγωγικό μέσα σε ένα αλφαριθμητικό : +"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" + +/* + Τα τριπλά διπλά-εισαγωγικά επιτρέπουν στα αλφαριθμητικά να εκτείνονται σε + πολλαπλές γραμμές και να περιέχουν διπλά εισαγωγικά +*/ +val html = """<form id="daform"> + <p>Press belo', Joe</p> + <input type="submit"> + </form>""" + + +///////////////////////////////////////////////// +// 2. Συναρτήσεις +///////////////////////////////////////////////// + +// Οι συναρτήσεις ορίζονται ως εξής: +// +// def functionName(args...): ReturnType = { body... } +// +// Αν προέρχεστε απο πιο παραδοσιακές γλώσσες (C/C++ , Java) παρατηρήστε +// την παράλειψη του return. Στην Scala , η τελευταία έκφραση στο μπλόκ +// της συνάρτησης είναι η τιμή που επιστρέφει η συνάρτηση. +def sumOfSquares(x: Int, y: Int): Int = { + val x2 = x * x + val y2 = y * y + x2 + y2 +} + +// Τα { } μπορούν να παραλειφθούν αν η συνάρτηση αποτελείται απο μια απλή έκφραση: +def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y + +// Η σύνταξη για την κλήση συναρτήσεων είναι γνώριμη: +sumOfSquares(3, 4) // => 25 + +// Στις περισσότερες των περιπτώσεων (με τις αναδρομικές συναρτήσεις να αποτελούν +// την πιο αξιοπρόσεκτη εξαίρεση) , ο τύπος επιστροφής της συνάρτησης μπορεί να +// παραλειφθεί, και η ίδια συμπερασματολογία τύπων που είδαμε με τις μεταβλητές +// θα δουλεύει και με τους τύπους επιστροφής της συνάρτησης: +def sq(x: Int) = x * x // Ο μεταγλωττιστής μπορεί να μαντέψει ότι + // ο τύπος επιστροφής της συνάρτησης είναι Int + +// Οι συναρτήσεις μπορούν να έχουν προκαθορισμένες τιμές: +def addWithDefault(x: Int, y: Int = 5) = x + y +addWithDefault(1, 2) // => 3 +addWithDefault(1) // => 6 + + +// Οι ανώνυμες συναρτήσεις είναι ως εξής: +(x:Int) => x * x + +// Σε αντίθεση με τα defs , ακόμα και ο τύπος εισόδου απο τις ανώνυμες +// συναρτήσεις μπορεί να παραληφθεί αν τα συμφραζόμενα το κάνουν ξεκάθαρο. +// Προσέξτε τον τύπο "Int => Int" που σημαίνει ότι μια συνάρτηση παίρνει +// ένα Int και επιστρέφει ένα Int. +val sq: Int => Int = x => x * x + +// Οι ανώνυμες συναρτήσεις μπορούν να κληθούν όπως συνήθως: +sq(10) // => 100 + +// Αν κάθε όρισμα στην ανώνυμη συνάρτηση χρησιμοποιείται μόνο μία φορά, +// η Scala επιτρέπει έναν ακόμα πιο σύντομο τρόπο να οριστεί. Αυτές +// οι ανώνυμες συναρτήσεις αποδεικνύεται ότι είναι πολύ κοινές , +// όπως θα γίνει προφανές στο μέρος των δομών δεδομένων. +val addOne: Int => Int = _ + 1 +val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) + +addOne(5) // => 6 +weirdSum(2, 4) // => 16 + +// Η δεσμευμένη λέξη return υπάρχει στην Scala , αλλά επιστρέφει μόνο +// από το πιο εσωτερικό def που την περικλείει. +// ΠΡΟΣΟΧΗ: Η χρήση του return στην Scala είναι επιρρεπής σε λάθη +// και θα πρέπει να αποφεύγεται. +// Δεν έχει καμία επίδραση στις ανώνυμες συναρτήσεις. Για παράδειγμα: +def foo(x: Int): Int = { + val anonFunc: Int => Int = { z => + if (z > 5) + return z // Αυτή η σειρά κάνει το z την τιμή που επιστρέφει η foo! + else + z + 2 // Αυτή η γραμμή είναι η τιμή που επιστρέφει η anonFunc + } + anonFunc(x) // Αυτή η γραμμή είναι η τιμή που επιστρέφει η foo +} + + +///////////////////////////////////////////////// +// 3. Έλεγχος ροής +///////////////////////////////////////////////// + +1 to 5 +val r = 1 to 5 +r.foreach( println ) + +r foreach println +// ΠΡΟΣΟΧΗ: Η Scala είναι σχετικά επιεικής ως αναφορά τις τελείες και +// τις παρενθέσεις. Διαβάστε τους κανόνες ξεχωριστά. +// Αυτό βοηθάει στο να γράφεις DSLs και APIs που διαβάζονται σαν τα Αγγλικά. + +(5 to 1 by -1) foreach ( println ) + +// Ένας βρόχος while : +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + +while (i < 10) { println("i " + i); i+=1 } // Ναι ξανά! Τι συνέβει; Γιατί; + +i // Εμφάνισε την τιμή του i. Σημειώστε ότι ένας βρόχος while είναι βρόχος + // με την κλασική έννοια - εκτελείται σειριακά καθώς αλλάζει η μεταβλητή + // του βρόχου. Το while είναι πολύ γρήγορο , γρηγορότερο απο τους βρόχους + // της Java , αλλά η χρήση combinators και comprehensions όπως πιο πάνω , + // είναι πιο εύκολη στην κατανόηση και στην παραλληλοποίηση. + +// Ένας βρόχος do while : +do { + println("x is still less than 10"); + x += 1 +} while (x < 10) + +// Η αναδρομή ουράς είναι ένας ιδιωματικός τρόπος να κάνεις επαναλαμβανόμενα +// πράγματα στην Scala. Οι αναδρομικές συναρτήσεις απαιτούν να γράφτεί +// ρητά ο τύπος που θα επιστρέψουν , αλλιώς ο μεταγλωττιστής δεν μπορεί +// αλλιώς να τον συνάγει. Παρακάτω είναι μια συνάρτηση που επιστρέφει Unit. +def showNumbersInRange(a:Int, b:Int):Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} +showNumbersInRange(1,14) + + +// Έλεγχος Ροής + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + + +///////////////////////////////////////////////// +// 4. Δομές Δεδομένων +///////////////////////////////////////////////// + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // "Πετάει" exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // "Πετάει" exception + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* Δείτε το documentation του map εδώ - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + */ + + +// Πλειάδες + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// Γιατί να το έχουμε αυτό; +val divideInts = (x:Int, y:Int) => (x / y, x % y) + +divideInts(10,3) // Η συνάρτηση divideInts επιστρέφει το αποτέλεσμα + // της ακαίρεας διαίρεσης και το υπόλοιπο. + +// Για να έχουμε πρόσβαση στα στοιχεία μιας πλειάδας, χρησιμοποιούμε το _._n +// όπου το n είναι ο δείκτης με βάση το 1 του στοιχείου. +val d = divideInts(10,3) + +d._1 + +d._2 + + +///////////////////////////////////////////////// +// 5. Αντικειμενοστραφής Προγραμματισμός +///////////////////////////////////////////////// + +/* + Ότι έχουμε κάνει ως τώρα σε αυτό το tutorial ήταν απλές εκφράσεις + (τιμές , συναρτήσεις , κτλ). Αυτές οι εκφράσεις βολεύουν όταν τις + γράφουμε στο REPL για γρήγορες δοκιμές, αλλά δεν μπορούν να υπάρχουν + από μόνες τους σε ένα αρχείο Scala. Για παράδειγμα , δεν μπορούμε να + έχουμε μόνο ένα "val x = 5" στο αρχείο Scala. Αντί αυτού , τα μόνα + στοιχεία του πάνω επιπέδου που επιτρέπονται στην Scala είναι: + + - αντικείμενα (objects) + - κλάσεις (classes) + - κλάσεις περίπτωσης (case classes στην Scala) + - Χαρακτηριστικά (traits , όπως ονομάζονται στην Scala) + + Και τώρα θα εξηγήσουμε τι είναι αυτά. +*/ +// Οι κλάσεις είναι παρόμοιες με τις κλάσεις σε άλλες γλώσσες. Τα ορίσματα του +// "κατασκευαστή" (constructor) δηλώνονται μετά από το όνομα της κλάσης , +// και η αρχικοποιήση γίνεται μέσα στο σώμα της κλάσης. +class Dog(br: String) { + // Κώδικας για τον "κατασκευαστή" + var breed: String = br + + // Ορίζεται μια μέθοδος bark , που επιστρέφει ένα αλφαριθμητικό + def bark = "Woof, woof!" + + // Οι τιμές και οι μέθοδοι είναι public εκτός αν χρησιμοποιήσουμε κάποια + // απο τις λέξεις κλειδιά "protected" και "private" . + private def sleep(hours: Int) = + println(s"I'm sleeping for $hours hours") + + // Οι abstract μέθοδοι είναι απλά μέθοδοι χωρίς σώμα. Αν βγάζαμε + // το σχόλιο απο την επόμενη γραμμή η κλάση Dog θα έπρεπε να + // δηλωθεί ως abstract class Dog(...) { ... } : + // def chaseAfter(what: String): String +} + +val mydog = new Dog("greyhound") +println(mydog.breed) // => "greyhound" +println(mydog.bark) // => "Woof, woof!" + + +// Η λέξη "object" δημιουργεί ένα type ΚΑΙ ένα singleton instance αυτού. +// Είναι κοινό για τις κλάσεις στην Scala να έχουν ένα "συντροφικό object", +// όπου η συμπεριφορά για κάθε instance αιχμαλωτίζεται μέσα στις κλάσεις +// αυτές καθ' αυτές, αλλά η συμπρεριφορά που σχετίζεται με όλα τα instances +// της κλάσης πάνε μέσα στο object. Η διαφορά είναι παρόμοια με τις +// μεθόδους κλάσεων σε σχέση με στατικές μεθόδους σε άλλες γλώσσες. +// Προσέξτε οτι τα objects και οι κλάσεις μπορούν να έχουν το ίδιο όνομα. +object Dog { + def allKnownBreeds = List("pitbull", "shepherd", "retriever") + def createDog(breed: String) = new Dog(breed) +} + +// Οι κλάσεις περίπτωσης (case classes) είναι που έχουν την επιπλέον +// λειτουργικότητα ενσωματωμένη. Μιά συνήθης ερώτηση για αρχάριους στην +// Scala είναι πότε να χρησιμοπούνται κλάσεις και πότε case κλάσεις. +// Γενικά οι κλάσεις τείνουν να εστιάζουν στην ενθυλάκωση, τον +// πολυμορφισμό και τη συμπεριφορά. Οι τιμές μέσα σε αυτές τις κλάσεις +// τείνουν να είναι private , και μόνο οι μέθοδοι είναι εκτεθειμένες. +// Ο κύριος σκοπός των case classes είναι να κρατούν δεδομένα που είναι +// σταθερές(immutable). Συνήθως έχουν λίγες μεθόδους και οι μέθοδοι σπάνια +// έχουν παρενέργειες. +case class Person(name: String, phoneNumber: String) + +// Δημιουργία ενός instance. Πραρατηρήστε ότι τα case classes +// δεν χρειάζονται την λέξη "new" . +val george = Person("George", "1234") +val kate = Person("Kate", "4567") + +// Με τα case classes, παίρνεις μερικά προνόμια δωρεάν , όπως: +george.phoneNumber // => "1234" + +// Ελέχγεται η ισότητα για κάθε πεδίο (δεν χρειάζεται να +// κάνουμε override στο .equals) +Person("George", "1234") == Person("Kate", "1236") // => false + +// Έυκολος τρόπος να κάνουμε αντιγραφή. Δημιουργούμε έναν νέο geroge: +// otherGeorge == Person("george", "9876") +val otherGeorge = george.copy(phoneNumber = "9876") + +// Και πολλά άλλα. Τα case classes έχουν και αντιστοίχιση προτύπων +// (pattern matching) δωρεάν, δείτε παρακάτω. + +// Τα χαρακτηριστικά (traits) έρχονται σε λίγο καιρό ! + +///////////////////////////////////////////////// +// 6. Αντιστοίχιση Προτύπων +///////////////////////////////////////////////// + +// Η αντιστοίχιση προτύπων (pattern matching) είναι ένα πολύ δυνατό και +// ευρέως χρησιμοποιούμενο χαρακτηριστικό στην Scala. Παρακάτω βλέπουμε +// πως γίνεται το pattern matching σε ένα case class. Σημείωση: Σε +// αντίθεση με άλλες γλώσσες η Scala δεν χρειάζεται breaks, γιατί γίνεται +// αυτόματα όταν γίνει κάποιο match. + +def matchPerson(person: Person): String = person match { + // Μετά προσδιορίζουμε το πρότυπο (pattern): + case Person("George", number) => "We found George! His number is " + number + case Person("Kate", number) => "We found Kate! Her number is " + number + case Person(name, number) => "We matched someone : " + name + ", phone : " + number +} + +val email = "(.*)@(.*)".r // Ορίζουμε ένα regex για το επόμενο παράδειγμα. + // (regex <- REGular EXpression) + +// Το pattern matching μπορεί να μοιάζει γνώριμο απο τα switch statements σε +// γλώσσες που ανήκουν στην οικογένεια της C αλλά είναι πολύ πιο ισχυρό. +// Στην Scala , μπορούμε να κάνουμε match πολύ περισσότερα: +def matchEverything(obj: Any): String = obj match { + // Μπορούμε να ταιριάξουμε τιμές: + case "Hello world" => "Got the string Hello world" + + // Μπορούμε να ταιριάξουμε τύπους: + case x: Double => "Got a Double: " + x + + // Μπορούμε να βάλουμε συνθήκες: + case x: Int if x > 10000 => "Got a pretty big number!" + + // Μπορούμε να ταιριάξουμε case classes όπως πρίν: + case Person(name, number) => s"Got contact info for $name!" + + // Μπορούμε να ταιριάξουμε regex: + case email(name, domain) => s"Got email address $name@$domain" + + // Μπορούμε να ταιριάξουμε πλειάδες: + case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" + + // Μπορούμε να ταιριάξουμε δομές δεδομένων: + case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" + + // Μπορούμε να ταιριάξουμε πρότυπα που το ένα είναι μέσα στο άλλο: + case List(List((1, 2,"YAY"))) => "Got a list of list of tuple" +} + +// Στην πραγματικότητα , μπορούμε να κάνουμε pattern matching σε όποιο αντικείμενο +// έχει την μέθοδο "unapply". Αυτό το χαρακτηριστικό είναι τόσο ισχυρό ώστε +// η Scala επιτρέπει να ορίστούν ολόκληρες συναρτήσεις σαν patterns. +val patternFunc: Person => String = { + case Person("George", number) => s"George's number: $number" + case Person(name, number) => s"Random person's number: $number" +} + + +///////////////////////////////////////////////// +// 7. Συναρτησιακός Προγραμματισμός +///////////////////////////////////////////////// + +// Η Scala επιτρέπει στις μεθόδους και τις συναρτήσεις να επιστρέφουν ή να +// δέχονται ως παραμέτρους άλλες μεθόδους ή συναρτήσεις. + +val add10: Int => Int = _ + 10 // Μια συνάρτηση που δέχεται Int και επιστρέφει Int +List(1, 2, 3) map add10 // List(11, 12, 13) - το add10 εφαρμόζεται σε κάθε στοιχείο + // μέσω του map + +// Οι ανώνυμες συναρτήσεις μπορούν να χρησιμοποιηθούν αντί +// ονοματισμένων (όπως απο πάνω) : +List(1, 2, 3) map (x => x + 10) + +// Και το σύμβολο της κάτω παύλας , μπορεί να χρησιμοποιηθεί αν υπάρχει μόνο +// ένα όρισμα στην ανώνυμη συνάρτηση. Έτσι δεσμεύεται ως η μεταβλητή. +List(1, 2, 3) map (_ + 10) + +// Αν το μπλόκ της ανώνυμης συνάρτησης ΚΑΙ η συνάρτηση που εφαρμόζεται +// (στην περίπτωσή μας το foreach και το println) παίρνουν ένα όρισμα +// μπορείτε να παραλείψετε την κάτω παύλα. +List("Dom", "Bob", "Natalia") foreach println + + +// Συνδυαστές + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + +// Η συνάρτηση filter παίρνει ένα κατηγορούμενο (predicate) +// που είναι μια συνάρτηση απο το A -> Boolean και διαλέγει +// όλα τα στοιχεία που ικανοποιούν αυτό το κατηγορούμενο. +List(1, 2, 3) filter (_ > 2) // List(3) +case class Person(name:String, age:Int) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + + +// Το foreach είναι μια μέθοδος της Scala , που ορίζεται για ορισμένες +// συλλογές (collections). Παίρνει έναν τύπο και επιστρέφει Unit +// (μια μέθοδο void) +val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + +// For comprehensions + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + +/* + Προσοχή : Αυτά δεν ήταν βρόχοι for. Η σημασιολογία ενός βρόχου for είναι + η επανάληψη, ενώ ένα for-comprehension ορίζει μια σχέση μεταξύ δύο + συνόλων δεδομένων. +*/ + +///////////////////////////////////////////////// +// 8. Implicits +///////////////////////////////////////////////// +/* + ΠΡΟΣΟΧΗ! Τα implicits είναι ένα σύνολο απο ισχυρά χαρακτηριστικά της Scala + και επομένως είναι εύκολο να γίνει κατάχρηση. Οι αρχάριοι στην Scala θα + πρέπει να αντισταθούν στον πειρασμό να τα χρησιμοποιήσουν έως ότου, όχι + μόνο καταλάβουν πως λειτουργούν, αλλά ακόμα εξασκηθούν πάνω τους. + Ο μόνος λόγος που συμπεριλάβαμε αυτό το κομμάτι στο tutorial είναι + γιατί είναι τόσο κοινό στις βιβλιοθήκες της Scala , που αδύνατο να κάνεις + οτιδήποτε σημαντικό χωρίς να χρησιμοποιήσεις μια που να έχει implicits. + +*/ + +// Κάθε τιμή (vals , συναρτήσεις , αντικείμενα , κτλ) μπορεί να δηλωθεί ως +// implicit χρησιμοποιώντας , ναι το μαντέψατε , την λέξη "implicit". +// Σημειώστε ότι χρησιμοποιούμε την κλάση Dog που δημιουργήσαμε στο +// 5ο μέρος των παραδειγμάτων. +implicit val myImplicitInt = 100 +implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed) + + +// Απο μόνη της, η λέξη implicit, δεν αλλάζει την συμπεριφορά μιάς τιμής +// οπότε οι παραπάνω μπορούν να χρησιμοποιοηθούν όπως συνήθως. +myImplicitInt + 2 // => 102 +myImplicitFunction("Pitbull").breed // => "Golden Pitbull" + +// Η διαφορά είναι ότι τώρα αυτές οι τιμές έχουν την δυνατότητα να +// χρησιμοποιηθούν όταν ένα άλλο κομμάτι κώδικα "χρειάζεται" μια +// implicit τιμή. Μια τέτοια περίπτωση είναι τα ορίσματα μιας implicit +// συνάρτησης: +def sendGreetings(toWhom: String)(implicit howMany: Int) = + s"Hello $toWhom, $howMany blessings to you and yours!" + +// Άν τροφοδοτήσουμε μια τιμή για το "homMany", η συνάρτηση συμπεριφέρεται +// ως συνήθως +sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" + +// Αλλά αν παραλείψουμε την παράμετρο implicit , μια implicit τιμή του ιδίου τύπου +// χρησιμοποιείται, στην περίπτωσή μας, το "myImplicitInt" +sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" + +// Οι παράμετροι implicit συναρτήσεων μας επιτρέπουν να προσομοιάζουμε +// κλάσεις τύπων (type classes) σε άλλες συναρτησιακές γλώσσες. +// Χρησιμοποιείται τόσο συχνά που έχει την δικιά του συντομογραφία. +// Οι επόμενες δύο γραμμές κώδικα σημαίνουν το ίδιο πράγμα. +def foo[T](implicit c: C[T]) = ... +def foo[T : C] = ... + + + +// Μια άλλη περίπτωση στην οποία ο μεταγλωττιστής αναζητά μια implicit τιμή +// είναι αν έχετε obj.method (...) +// αλλά το "obj" δεν έχει την "method" ως μέθοδο. Σε αυτή την περίπτωση, +// αν υπάρχει μια implicit μετατροπή του τύπου Α => Β, όπου Α είναι ο τύπος +// του obj, ενώ το Β έχει μία μέθοδο που ονομάζεται «method», εφαρμόζεται η +// εν λόγω μετατροπή. Έτσι, έχοντας την MyImplicitFunction μέσα στο πεδίο +// εφαρμογής(scope), μπορούμε να πούμε: +"Retriever".breed // => "Golden Retriever" +"Sheperd".bark // => "Woof, woof!" + +// Εδώ το String αρχικά μετατρέπεται σε Dog χρησιμοποιώντας την συνάρτησή μας +// παραπάνω, και μετά καλείται η κατάλληλη μέθοδος. Αυτό είναι ένα εξερετικά +// ισχυρό χαρακτηριστικό, αλλά δεν πρέπει να χρησιμοποιείται με ελαφριά την +// καρδιά. Μάλιστα, όταν ορίσατε την συνάρτηση implicit παραπάνω, ο μεταγλωττιστής +// θα πρέπει να σας έδωσε μια προειδοποιήση, ότι δεν πρέπει να το κάνετε αυτό +// εκτός αν πραγματικά γνωρίζετε τι κάνετε. + + +///////////////////////////////////////////////// +// 9. Διάφορα +///////////////////////////////////////////////// + +// Εισαγωγή βιβλιοθηκών κτλ +import scala.collection.immutable.List + +// Εισαγωγή των πάντων απο το scala.collection.immutable +import scala.collection.immutable._ + +// Εισαγωγή πολλών κλάσεων σε μία έκφραση +import scala.collection.immutable.{List, Map} + +// Δώστε ένα νέο όνομα στην εισαγωγή σας χρησιμοποιώντας το '=>' +import scala.collection.immutable.{ List => ImmutableList } + +// Εισαγωγή όλων των κλάσεων εκτός απο μερικές. +// Το επόμενο δεν εισάγει το Map και το Set: +import scala.collection.immutable.{Map => _, Set => _, _} + +// Το σημείο εισαγωγής του προγράμματος σας ορίζεται σε ένα αρχείο scala , +// χρησιμοποιώντας ένα αντικείμενο (object), με μία μέθοδο , την main. +object Application { + def main(args: Array[String]): Unit = { + // Εδω γράφουμε ... + } +} + +// Files can contain multiple classes and objects. Compile with scalac +// Τα files μπορούν να περιέχουν περισσότερες απο μία κλάσεις και +// αντικείμενα. Το compile γίνεται με την εντολή scalac + +// Εισαγωγή και εξαγωγή. + +// Για να διβάσετε ένα αρχείο γραμμή προς γραμμή +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// Για να γράψετε σε ένα αρχείο +val writer = new PrintWriter("myfile.txt") +writer.write("Writing line for line" + util.Properties.lineSeparator) +writer.write("Another line here" + util.Properties.lineSeparator) +writer.close() + +``` + +## Further resources + +[Scala for the impatient](http://horstmann.com/scala/) + +[Twitter Scala school](http://twitter.github.io/scala_school/) + +[The scala documentation](http://docs.scala-lang.org/) + +[Try Scala in your browser](http://scalatutorials.com/tour/) + +Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user) + diff --git a/elisp.html.markdown b/elisp.html.markdown index d3910759..3bed5d1c 100644 --- a/elisp.html.markdown +++ b/elisp.html.markdown @@ -29,7 +29,7 @@ filename: learn-emacs-lisp.el ;; I hereby decline any responsability. Have fun! ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; +;; ;; Fire up Emacs. ;; ;; Hit the `q' key to dismiss the welcome message. @@ -42,9 +42,9 @@ filename: learn-emacs-lisp.el ;; The scratch buffer is the default buffer when opening Emacs. ;; You are never editing files: you are editing buffers that you ;; can save to a file. -;; +;; ;; "Lisp interaction" refers to a set of commands available here. -;; +;; ;; Emacs has a built-in set of commands available in every buffer, ;; and several subsets of commands available when you activate a ;; specific mode. Here we use the `lisp-interaction-mode', which @@ -109,7 +109,7 @@ filename: learn-emacs-lisp.el ;; The empty parentheses in the function's definition means that ;; it does not accept arguments. But always using `my-name' is ;; boring, let's tell the function to accept one argument (here -;; the argument is called "name"): +;; the argument is called "name"): (defun hello (name) (insert "Hello " name)) ;; `C-xC-e' => hello @@ -280,10 +280,10 @@ filename: learn-emacs-lisp.el ;; should stop searching at some point in the buffer, and whether it ;; should silently fail when nothing is found: -;; (search-forward "Hello" nil t) does the trick: +;; (search-forward "Hello" nil 't) does the trick: ;; The `nil' argument says: the search is not bound to a position. -;; The `t' argument says: silently fail when nothing is found. +;; The `'t' argument says: silently fail when nothing is found. ;; We use this sexp in the function below, which doesn't throw an error: @@ -294,7 +294,7 @@ filename: learn-emacs-lisp.el (mapcar 'hello list-of-names) (goto-char (point-min)) ;; Replace "Hello" by "Bonjour" - (while (search-forward "Hello" nil t) + (while (search-forward "Hello" nil 't) (replace-match "Bonjour")) (other-window 1)) @@ -305,7 +305,7 @@ filename: learn-emacs-lisp.el (defun boldify-names () (switch-to-buffer-other-window "*test*") (goto-char (point-min)) - (while (re-search-forward "Bonjour \\(.+\\)!" nil t) + (while (re-search-forward "Bonjour \\(.+\\)!" nil 't) (add-text-properties (match-beginning 1) (match-end 1) (list 'face 'bold))) @@ -317,9 +317,9 @@ filename: learn-emacs-lisp.el ;; The regular expression is "Bonjour \\(.+\\)!" and it reads: ;; the string "Bonjour ", and -;; a group of | this is the \\( ... \\) construct -;; any character | this is the . -;; possibly repeated | this is the + +;; a group of | this is the \\( ... \\) construct +;; any character | this is the . +;; possibly repeated | this is the + ;; and the "!" string. ;; Ready? Test it! diff --git a/elixir.html.markdown b/elixir.html.markdown index 8ea499ff..c8599838 100644 --- a/elixir.html.markdown +++ b/elixir.html.markdown @@ -2,6 +2,7 @@ language: elixir contributors: - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] filename: learnelixir.ex --- @@ -9,9 +10,9 @@ Elixir is a modern functional language built on top of the Erlang VM. It's fully compatible with Erlang, but features a more standard syntax and many more features. -```ruby +```elixir -# Single line comments start with a hashtag. +# Single line comments start with a number symbol. # There's no multi-line comment, # but you can stack multiple comments. @@ -59,7 +60,7 @@ tail #=> [2,3] # the tuples have different sizes. # {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} -# There's also binaries +# There are also binaries <<1,2,3>> # binary # Strings and char lists @@ -90,6 +91,11 @@ string. <<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> "hello " <> "world" #=> "hello world" +# Ranges are represented as `start..end` (both inclusive) +1..10 #=> 1..10 +lower..upper = 1..10 # Can use pattern matching on ranges as well +[lower, upper] #=> [1, 10] + ## --------------------------- ## -- Operators ## --------------------------- @@ -108,7 +114,7 @@ div(10, 2) #=> 5 # To get the division remainder use `rem` rem(10, 3) #=> 1 -# There's also boolean operators: `or`, `and` and `not`. +# There are also boolean operators: `or`, `and` and `not`. # These operators expect a boolean as their first argument. true and true #=> true false or true #=> true @@ -119,7 +125,6 @@ false or true #=> true 1 || true #=> 1 false && 1 #=> false nil && 20 #=> nil - !true #=> false # For comparisons we have: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>` @@ -165,12 +170,12 @@ case {:one, :two} do {:four, :five} -> "This won't match" {:one, x} -> - "This will match and assign `x` to `:two`" + "This will match and bind `x` to `:two`" _ -> "This will match any value" end -# It's common practice to assign a value to `_` if we don't need it. +# It's common to bind the value to `_` if we don't need it. # For example, if only the head of a list matters to us: [head | _] = [1,2,3] head #=> 1 @@ -190,7 +195,7 @@ cond do "But I will" end -# It is common to see a last condition equal to `true`, which will always match. +# It is common to set the last condition equal to `true`, which will always match. cond do 1 + 1 == 3 -> "I will never be seen" @@ -201,7 +206,7 @@ cond do end # `try/catch` is used to catch values that are thrown, it also supports an -# `after` clause that is invoked whether or not a value is catched. +# `after` clause that is invoked whether or not a value is caught. try do throw(:hello) catch @@ -301,7 +306,7 @@ end Recursion.sum_list([1,2,3], 0) #=> 6 # Elixir modules support attributes, there are built-in attributes and you -# may also add custom attributes. +# may also add custom ones. defmodule MyMod do @moduledoc """ This is a built-in attribute on a example module. @@ -312,21 +317,24 @@ defmodule MyMod do end ## --------------------------- -## -- Records and Exceptions +## -- Structs and Exceptions ## --------------------------- -# Records are basically structures that allow you to associate a name with -# a particular value. -defrecord Person, name: nil, age: 0, height: 0 +# Structs are extensions on top of maps that bring default values, +# compile-time guarantees and polymorphism into Elixir. +defmodule Person do + defstruct name: nil, age: 0, height: 0 +end -joe_info = Person.new(name: "Joe", age: 30, height: 180) -#=> Person[name: "Joe", age: 30, height: 180] +joe_info = %Person{ name: "Joe", age: 30, height: 180 } +#=> %Person{age: 30, height: 180, name: "Joe"} # Access the value of name joe_info.name #=> "Joe" # Update the value of age -joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180] +older_joe_info = %{ joe_info | age: 31 } +#=> %Person{age: 31, height: 180, name: "Joe"} # The `try` block with the `rescue` keyword is used to handle exceptions try do @@ -358,9 +366,9 @@ f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> spawn(f) #=> #PID<0.40.0> # `spawn` returns a pid (process identifier), you can use this pid to send -# messages to the process. To do message passing we use the `<-` operator. +# messages to the process. To do message passing we use the `send` operator. # For all of this to be useful we need to be able to receive messages. This is -# achived with the `receive` mechanism: +# achieved with the `receive` mechanism: defmodule Geometry do def area_loop do receive do @@ -378,11 +386,11 @@ end pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> # Send a message to `pid` that will match a pattern in the receive statement -pid <- {:rectangle, 2, 3} +send pid, {:rectangle, 2, 3} #=> Area = 6 # {:rectangle,2,3} -pid <- {:circle, 2} +send pid, {:circle, 2} #=> Area = 12.56000000000000049738 # {:circle,2} @@ -394,5 +402,7 @@ self() #=> #PID<0.27.0> * [Getting started guide](http://elixir-lang.org/getting_started/1.html) from [elixir webpage](http://elixir-lang.org) * [Elixir Documentation](http://elixir-lang.org/docs/master/) +* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas +* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert -* "Programming Erlang: Software for a Concurrent World" by Joe Armstrong +* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) by Joe Armstrong diff --git a/erlang.html.markdown b/erlang.html.markdown index 065219ba..d6ed7b86 100644 --- a/erlang.html.markdown +++ b/erlang.html.markdown @@ -18,29 +18,32 @@ filename: learnerlang.erl % Periods (`.`) (followed by whitespace) separate entire functions and % expressions in the shell. % Semicolons (`;`) separate clauses. We find clauses in several contexts: -% function definitions and in `case`, `if`, `try..catch` and `receive` +% function definitions and in `case`, `if`, `try..catch`, and `receive` % expressions. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% 1. Variables and pattern matching. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% In Erlang new variables are bound with an `=` statement. Num = 42. % All variable names must start with an uppercase letter. -% Erlang has single assignment variables, if you try to assign a different value -% to the variable `Num`, you’ll get an error. +% Erlang has single-assignment variables; if you try to assign a different +% value to the variable `Num`, you’ll get an error. Num = 43. % ** exception error: no match of right hand side value 43 % In most languages, `=` denotes an assignment statement. In Erlang, however, -% `=` denotes a pattern matching operation. `Lhs = Rhs` really means this: -% evaluate the right side (Rhs), and then match the result against the pattern -% on the left side (Lhs). +% `=` denotes a pattern-matching operation. When an empty variable is used on the +% left hand side of the `=` operator to is bound (assigned), but when a bound +% variable is used on the left hand side the following behaviour is observed. +% `Lhs = Rhs` really means this: evaluate the right side (`Rhs`), and then +% match the result against the pattern on the left side (`Lhs`). Num = 7 * 6. -% Floating point number. +% Floating-point number. Pi = 3.14159. -% Atoms, are used to represent different non-numerical constant values. Atoms +% Atoms are used to represent different non-numerical constant values. Atoms % start with lowercase letters, followed by a sequence of alphanumeric % characters or the underscore (`_`) or at (`@`) sign. Hello = hello. @@ -53,34 +56,34 @@ AtomWithSpace = 'some atom with space'. % Tuples are similar to structs in C. Point = {point, 10, 45}. -% If we want to extract some values from a tuple, we use the pattern matching +% If we want to extract some values from a tuple, we use the pattern-matching % operator `=`. {point, X, Y} = Point. % X = 10, Y = 45 % We can use `_` as a placeholder for variables that we’re not interested in. % The symbol `_` is called an anonymous variable. Unlike regular variables, -% several occurrences of _ in the same pattern don’t have to bind to the same -% value. +% several occurrences of `_` in the same pattern don’t have to bind to the +% same value. Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. {_, {_, {_, Who}, _}, _} = Person. % Who = joe % We create a list by enclosing the list elements in square brackets and % separating them with commas. % The individual elements of a list can be of any type. -% The first element of a list is the head of the list. If you imagine removing the -% head from the list, what’s left is called the tail of the list. +% The first element of a list is the head of the list. If you imagine removing +% the head from the list, what’s left is called the tail of the list. ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. % If `T` is a list, then `[H|T]` is also a list, with head `H` and tail `T`. % The vertical bar (`|`) separates the head of a list from its tail. % `[]` is the empty list. -% We can extract elements from a list with a pattern matching operation. If we +% We can extract elements from a list with a pattern-matching operation. If we % have a nonempty list `L`, then the expression `[X|Y] = L`, where `X` and `Y` % are unbound variables, will extract the head of the list into `X` and the tail % of the list into `Y`. [FirstThing|OtherThingsToBuy] = ThingsToBuy. % FirstThing = {apples, 10} -% OtherThingsToBuy = {pears, 6}, {milk, 3} +% OtherThingsToBuy = [{pears, 6}, {milk, 3}] % There are no strings in Erlang. Strings are really just lists of integers. % Strings are enclosed in double quotation marks (`"`). @@ -117,17 +120,19 @@ c(geometry). % {ok,geometry} geometry:area({rectangle, 10, 5}). % 50 geometry:area({circle, 1.4}). % 6.15752 -% In Erlang, two functions with the same name and different arity (number of arguments) -% in the same module represent entirely different functions. +% In Erlang, two functions with the same name and different arity (number of +% arguments) in the same module represent entirely different functions. -module(lib_misc). --export([sum/1]). % export function `sum` of arity 1 accepting one argument: list of integers. +-export([sum/1]). % export function `sum` of arity 1 + % accepting one argument: list of integers. sum(L) -> sum(L, 0). sum([], N) -> N; sum([H|T], N) -> sum(T, H+N). -% Funs are "anonymous" functions. They are called this way because they have no -% name. However they can be assigned to variables. -Double = fun(X) -> 2*X end. % `Double` points to an anonymous function with handle: #Fun<erl_eval.6.17052888> +% Funs are "anonymous" functions. They are called this way because they have +% no name. However, they can be assigned to variables. +Double = fun(X) -> 2 * X end. % `Double` points to an anonymous function + % with handle: #Fun<erl_eval.6.17052888> Double(2). % 4 % Functions accept funs as their arguments and can return funs. @@ -140,8 +145,9 @@ Triple(5). % 15 % The notation `[F(X) || X <- L]` means "the list of `F(X)` where `X` is taken % from the list `L`." L = [1,2,3,4,5]. -[2*X || X <- L]. % [2,4,6,8,10] -% A list comprehension can have generators and filters which select subset of the generated values. +[2 * X || X <- L]. % [2,4,6,8,10] +% A list comprehension can have generators and filters, which select subset of +% the generated values. EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] % Guards are constructs that we can use to increase the power of pattern @@ -155,17 +161,31 @@ max(X, Y) -> Y. % A guard is a series of guard expressions, separated by commas (`,`). % The guard `GuardExpr1, GuardExpr2, ..., GuardExprN` is true if all the guard -% expressions `GuardExpr1, GuardExpr2, ...` evaluate to true. +% expressions `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN` evaluate to `true`. is_cat(A) when is_atom(A), A =:= cat -> true; is_cat(A) -> false. is_dog(A) when is_atom(A), A =:= dog -> true; is_dog(A) -> false. -% A `guard sequence` is either a single guard or a series of guards, separated -%by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at least -% one of the guards `G1, G2, ...` evaluates to true. -is_pet(A) when is_dog(A); is_cat(A) -> true; -is_pet(A) -> false. +% We won't dwell on the `=:=` operator here; just be aware that it is used to +% check whether two Erlang expressions have the same value *and* the same type. +% Contrast this behaviour to that of the `==` operator: +1 + 2 =:= 3. % true +1 + 2 =:= 3.0. % false +1 + 2 == 3.0. % true + +% A guard sequence is either a single guard or a series of guards, separated +% by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at +% least one of the guards `G1`, `G2`, ..., `Gn` evaluates to `true`. +is_pet(A) when is_atom(A), (A =:= dog) or (A =:= cat) -> true; +is_pet(A) -> false. + +% Warning: not all valid Erlang expressions can be used as guard expressions; +% in particular, our `is_cat` and `is_dog` functions cannot be used within the +% guard sequence in `is_pet`'s definition. For a description of the +% expressions allowed in guard sequences, refer to this +% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912) +% of the Erlang reference manual. % Records provide a method for associating a name with a particular element in a % tuple. @@ -188,7 +208,7 @@ X = #todo{}. X1 = #todo{status = urgent, text = "Fix errata in book"}. % #todo{status = urgent, who = joe, text = "Fix errata in book"} X2 = X1#todo{status = done}. -% #todo{status = done,who = joe,text = "Fix errata in book"} +% #todo{status = done, who = joe, text = "Fix errata in book"} % `case` expressions. % `filter` returns a list of all elements `X` in a list `L` for which `P(X)` is @@ -206,11 +226,11 @@ max(X, Y) -> if X > Y -> X; X < Y -> Y; - true -> nil; + true -> nil end. -% Warning: at least one of the guards in the `if` expression must evaluate to true; -% otherwise, an exception will be raised. +% Warning: at least one of the guards in the `if` expression must evaluate to +% `true`; otherwise, an exception will be raised. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -218,7 +238,7 @@ max(X, Y) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Exceptions are raised by the system when internal errors are encountered or -% explicitly in code by calling `throw(Exception)`, `exit(Exception)` or +% explicitly in code by calling `throw(Exception)`, `exit(Exception)`, or % `erlang:error(Exception)`. generate_exception(1) -> a; generate_exception(2) -> throw(a); @@ -227,7 +247,7 @@ generate_exception(4) -> {'EXIT', a}; generate_exception(5) -> erlang:error(a). % Erlang has two methods of catching an exception. One is to enclose the call to -% the function, which raised the exception within a `try...catch` expression. +% the function that raises the exception within a `try...catch` expression. catcher(N) -> try generate_exception(N) of Val -> {N, normal, Val} @@ -241,6 +261,80 @@ catcher(N) -> % exception, it is converted into a tuple that describes the error. catcher(N) -> catch generate_exception(N). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 4. Concurrency +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Erlang relies on the actor model for concurrency. All we need to write +% concurrent programs in Erlang are three primitives: spawning processes, +% sending messages and receiving messages. + +% To start a new process, we use the `spawn` function, which takes a function +% as argument. + +F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768> +spawn(F). % <0.44.0> + +% `spawn` returns a pid (process identifier); you can use this pid to send +% messages to the process. To do message passing, we use the `!` operator. +% For all of this to be useful, we need to be able to receive messages. This is +% achieved with the `receive` mechanism: + +-module(calculateGeometry). +-compile(export_all). +calculateArea() -> + receive + {rectangle, W, H} -> + W * H; + {circle, R} -> + 3.14 * R * R; + _ -> + io:format("We can only calculate area of rectangles or circles.") + end. + +% Compile the module and create a process that evaluates `calculateArea` in the +% shell. +c(calculateGeometry). +CalculateArea = spawn(calculateGeometry, calculateArea, []). +CalculateArea ! {circle, 2}. % 12.56000000000000049738 + +% The shell is also a process; you can use `self` to get the current pid. +self(). % <0.41.0> + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 5. Testing with EUnit +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Unit tests can be written using EUnits's test generators and assert macros +-module(fib). +-export([fib/1]). +-include_lib("eunit/include/eunit.hrl"). + +fib(0) -> 1; +fib(1) -> 1; +fib(N) when N > 1 -> fib(N-1) + fib(N-2). + +fib_test_() -> + [?_assert(fib(0) =:= 1), + ?_assert(fib(1) =:= 1), + ?_assert(fib(2) =:= 2), + ?_assert(fib(3) =:= 3), + ?_assert(fib(4) =:= 5), + ?_assert(fib(5) =:= 8), + ?_assertException(error, function_clause, fib(-1)), + ?_assert(fib(31) =:= 2178309) + ]. + +% EUnit will automatically export to a test() function to allow running the tests +% in the erlang shell +fib:test() + +% The popular erlang build tool Rebar is also compatible with EUnit +% ``` +% rebar eunit +% ``` + ``` ## References diff --git a/es-es/bash-es.html.markdown b/es-es/bash-es.html.markdown new file mode 100644 index 00000000..fb89b2a0 --- /dev/null +++ b/es-es/bash-es.html.markdown @@ -0,0 +1,196 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] +translators: + - ["Daniel Zendejas", "https://github.com/danielzendejas"] +filename: LearnBash-es.sh +lang: es-es +--- + +Tutorial de Shell en español. + +Bash es el nombre del shell de unix, el cual también es distribuido como +el shell del sistema operativo GNU. También es el shell +por defecto de Linux y Mac OS X. Casi todos los ejemplos abajo pueden +ser parte de un script shell o ser ejecutados directamente en la terminal. + +[Leer más aquí.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash + +# La primera línea del script es el [shebang](http://en.wikipedia.org/wiki/Shebang_(Unix)) que le indica al sistema +# cómo ejecutar el script. +# Como te habrás dado cuenta, los comentarios en shell empiezan con #. +# El shebang también es un comentario. + +# Ejemplo sencillo de hola mundo: +echo ¡Hola mundo! + +# Cada comando empieza con una nueva línea, o después de un punto y coma: +echo 'Esta es la primera línea'; echo 'Esta es la segunda línea' + +# Para declarar una variable se hace lo siguiente: +VARIABLE="Mi string" + +# Pero no así: +VARIABLE = "Mi string" + +# Bash decidirá que VARIABLE es un comando a ejecutar, dando un error. + +# Usando la variable: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' + +# Cuando la variable es usada - o asignada, exportada, etcétera - se +# escribe su nombre sin $. Si se quiere saber el valor de la variables, +# entonces sí se usa $. Note que ' (comilla simple) no expandirá las +# variables. + +# Sustitución de strings en variables. +echo ${VARIABLE/Mi/Una} +# Esto sustituirá la primera cadena "Mi" con "Una". + +# Substring de una variable. +echo ${VARIABLE:0:7} +# Esto va a regresar sólo los primeros 7 caracteres del valor. + +# Valor por defecto de una variable +echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"} +# Esto trabaja para null (VARIABLE=), string vacío (VARIABLE=""), } +# cero (VARIABLE=0) regresa 0 + +# Variables del sistema: +# Aquí hay algunas variables incluídas en el sistema: +echo "El valor de regreso del último programa: $?" +echo "PID del sistema: $$" +echo "Número de argumentos: $#" +echo "Argumentos del script: $@" +echo "Argumentos del script separados en variables: $1 $2..." + +# Para leer un valor del input: +echo "¿Cuál es tu nombre?" +read NOMBRE # Note que no necesitamos declarar una variable +echo ¡Hola, $NOMBRE! + +# Tenemos la estructura 'if' usual: +# use 'man test' para más información sobre condicionales +if [ $NOMBRE -ne $USER ] +then + echo "Tu nombre es tu usuario." +else + echo "Tu nombre no es tu usuario." +fi + +# También hay ejecuciones condicionadas. +echo "Siempre ejecutado" || echo "Sólo ejecutado si el primer comando falla" +echo "Siempre ejecutado" && echo "Sólo ejecutado si el primer comando NO falla" + +# Para usar && y || con condicionales, se necesitan +# múltiples pares de corchetes: +if [ $NOMBRE == "Steve" ] && [ $EDAD -eq 15 ] +then + echo "Esto correrá si $NOMBRE es Steve Y $EDAD es 15." +fi + +if [ $NOMBRE == "Daniya" ] || [ $NOMBRE == "Zach" ] +then + echo "Esto correrá si $NOMBRE es Daniya O Zach." +fi + +# Las expresiones se denotan con el siguiente formato: +echo $(( 10 + 5 )) + +# A diferencia de otros lenguajes de programación, bash es shell , así que +# funciona en un contexto de directorio actual. Puedes listar archivos y +# directorios en un directorio actual con el comando 'ls': +ls + +# Estos comandos tienen opciones que controlan su ejecución: +ls -l # Lista todos los archivos y directorios en líneas distintas. + +# Los resultados del comando anterior pueden ser pasados al siguiente +# como input. El comando 'grep' filtra el input con los comandos provistos. +# Así es como podemos listar archivos .txt en el directorio actual: +ls -l | grep "\.txt" + +# Puedes también redireccionar el input y el error lanzado de algún comando. +python2 hello.py < "input.in" +python2 hello.py > "output.out" +python2 hello.py 2> "error.err" + +# El error lanzado eliminará el contenido del archivo si es que existe, +# para después escribir el error. Para que se concatene (en lugar de eliminar) +# use el comando ">>". + +# Los comandos pueden ser sustituidos dentro de otros comandos usando $(): +# El siguiente ejemplo despliega el número de archivos y directorios en el +# directorio actual. +echo "Hay $(ls | wc -l) elementos aquí." + +# Lo mismo puede ser hecho usando comillas invertidas `` pero no pueden ser +# anidadas. El método preferido es $(). +echo "Hay `ls | wc -l` elementos aquí." + +# Bash usa una estructura de casos similar al switch de Java o C++: +case "$VARIABLE" in + # Lista de patrones que las condiciones deben cumplir: + 0) echo "Hay un cero.";; + 1) echo "Hay un uno.";; + *) echo "No es null.";; +esac + +# Para los ciclos, se usa la estructura 'for'. Cicla para cada argumento dado: +# El contenido de $VARIABLE se imprime tres veces. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# ciclos while: +while [true] +do + echo "cuerpo del ciclo..." + break +done + +# También se pueden definir sub-rutinas (funciones) +# Definición: +function miFuncion () +{ + echo "Los argumentos trabajan igual que argumentos de script: $@" + echo "Y: $1 $2..." + echo "Esto es una función" + return 0 +} + +# O simplemente: +miOtraFuncion () +{ + echo "¡Otra forma de declarar funciones!" + return 0 +} + +# Para llamar a tu función +foo "Mi nombre es:" $NOMBRE + +# Hay muchos comandos útiles que puedes aprender: +# imprime las últimas 10 líneas del archivo file.txt +tail -n 10 file.txt +# imprime las primeras 10 líneas del archivo file.txt +head -n 10 file.txt +# ordena las líneas del archivo file.txt +sort file.txt +# identifica u omite las líneas repetidas, con -d las reporta +uniq -d file.txt +# imprime sólo la primera columna antes de cada ',' en el archivo| +cut -d ',' -f 1 file.txt +``` diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown new file mode 100644 index 00000000..e33d672d --- /dev/null +++ b/es-es/brainfuck-es.html.markdown @@ -0,0 +1,87 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +lang: es-es +--- + +Brainfuck (con mayúscula sólo al inicio de una oración) es un +lenguaje de programación mínimo, computacionalmente universal +en tamaño con sólo 8 comandos. + +``` + +Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas) +será ignorado. + +Brainfuck es representado por un arreglo de 30,000 celdas inicializadas +en cero y un apuntador en la celda actual. + +Existen ocho comandos: + ++ : Incrementa 1 al valor de la celda actual. +- : Decrementa 1 al valor de la celda actual. +> : Mueve el apuntador a la siguiente celda. (a la derecha) +< : Mueve el apuntador a la celda anterior. (a la izquierda) +. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A') +, : Lee un caracter como input y lo escribe en la celda actual. +[ : Si el valor en la celda actual es cero mueve el apuntador + hasta el primer ']' que encuentre. Si no es cero sigue a la + siguiente instrucción. +] : Si el valor en la celda actual es cero, entonces sigue con + la siguiente instrucción. Si no entonces mueve el apuntador + hacia atrás hasta encontrar el primer '['. + +[ y ] forman un while. Obviamente, deben estar balanceados. + +Ahora unos ejemplos de programas escritos con brainfuck. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a +6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo +([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces, +y se regresa a la celda #1 (<), para después decrementarla en 1 (-). +Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0), +cuando esto pasa se salta a (]) y continúa. + +En este punto estamos en la celda #1, que tiene un valor de 0, mientras +que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>), +la incrementamos 5 veces para tener un valor de 65 y luego imprimimos +el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A' +se imprime. + +, [ > + < - ] > . + +Este programa lee un caracter del input y lo copia en la celda #2 (,). +Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su +valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-). +Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un +cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre +terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.). + +Ten en mente que los espacios son sólo para fines de legibilidad. +Es lo mismo escribir el ejemplo de arriba que esto: +,[>+<-]>. + +Intenta descrifrar lo que hace este programa: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Este programa toma dos números como input y los multiplica. + +Primero recibe dos números del usuario. Luego empieza el ciclo externo, +condicionado en la celda #1. Luego se mueve a la celda #2, comenzando +el ciclo interno condicionado en la celda #2 incrementando la celda #3. +Sin embargo viene un problema: El ciclo interior no funcionará nuevamente +hasta la próxima vez. Para resolver este problema también incrementamos la +celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene +el resultado. +``` +Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir +tu propio intérprete de brainfuck o tu propio programa en brainfuck. El +intérprete es relativamente sencillo de hacer, pero si eres masoquista, +intenta construir tu proprio intérprete de brainfuck... en brainfuck. diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown new file mode 100644 index 00000000..bcc775e5 --- /dev/null +++ b/es-es/c++-es.html.markdown @@ -0,0 +1,829 @@ +--- +language: c++ +filename: learncpp.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Connor Waters", "http://github.com/connorwaters"] +translators: + - ["Gerson Lázaro", "https://gersonlazaro.com"] +lang: es-es +--- + +C++ es un lenguaje de programación de sistemas que, +[de acuerdo a su inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +fue diseñado para + +- ser un "mejor C" +- soportar abstracción de datos +- soportar programación orientada a objetos +- soportar programación genérica + +Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, +es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser +directamente ejecutadas por el procesador y ofrece un estricto control sobre +el hardware (como C), mientras ofrece características de alto nivel como +genericidad, excepciones, y clases. Esta combinación de velocidad y +funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados. + +```c++ +//////////////////// +// Comparación con C +//////////////////// + +// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las +// declaraciones de variables, tipos primitivos y funciones. + +// Al igual que en C, el punto de entrada de tu programa es una función llamada +// main con un retorno de tipo entero. +// Este valor sirve como código de salida del programa. +// Mira http://en.wikipedia.org/wiki/Exit_status para mayor información. +int main(int argc, char** argv) +{ + // Los argumentos de la línea de comandos se pasan por argc y argv de la + // misma manera que en C. + // argc indica el número de argumentos, + // y argv es un arreglo de strings de estilo C (char*) + // representando los argumentos. + // El primer argumento es el nombre con el que el programa es llamado. + // argc y argv pueden omitirse si no te preocupan los argumentos, + // dejando la definición de la función como int main () + + // Un estado de salida 0 indica éxito. + return 0; +} + +// Sin embargo, C ++ varía en algunas de las siguientes maneras: + +// En C++, los caracteres literales son caracteres +sizeof('c') == sizeof(char) == 1 + +// En C, los caracteres literales son enteros +sizeof('c') == sizeof(int) + + +// C++ tiene prototipado estricto +void func(); // función que no acepta argumentos + +// En C +void func(); // función que puede aceptar cualquier número de argumentos + +// Use nullptr en lugar de NULL en C++ +int* ip = nullptr; + +// Las cabeceras (headers) estándar de C están disponibles en C ++, +// pero tienen el prefijo "c" y no tienen sufijo .h. +#include <cstdio> + +int main() +{ + printf("Hola mundo!\n"); + return 0; +} + +////////////////////////// +// Sobrecarga de funciones +////////////////////////// + +// C++ soporta sobrecarga de funciones +// siempre que cada función tenga diferentes parámetros. + +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("Mi entero es %d", myInt); +} + +int main() +{ + print("Hello"); // Resolves to void print(const char*) + print(15); // Resolves to void print(int) +} + +//////////////////////////////////// +// Argumentos de función por defecto +//////////////////////////////////// + +// Puedes proporcionar argumentos por defecto para una función si no son +// proporcionados por quien la llama. + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // Hacer algo con los enteros aqui +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Los argumentos predeterminados deben estar al final de la lista de argumentos. + +void invalidDeclaration(int a = 1, int b) // Error! +{ +} + +///////////////////// +// Espacios de nombre +///////////////////// + +// Espacios de nombres proporcionan ámbitos separados para variable, función y +// otras declaraciones. +// Los espacios de nombres se pueden anidar. + +namespace First { + namespace Nested { + void foo() + { + printf("Esto es First::Nested::foo\n"); + } + } // fin del nombre de espacio Nested +} // fin del nombre de espacio First + +namespace Second { + void foo() + { + printf("Esto es Second::foo\n") + } +} + +void foo() +{ + printf("Este es global: foo\n"); +} + +int main() +{ + + // Incluye todos los símbolos del espacio de nombre Second en el ámbito + // actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora + // es ambigua si estamos llamando a foo en espacio de nombres Second o en + // el nivel superior. + using namespace Second; + + Second::foo(); // imprime "Esto es Second::foo" + First::Nested::foo(); // imprime "Esto es First::Nested::foo" + ::foo(); // imprime "Este es global: foo" +} + +///////////////// +// Entrada/Salida +///////////////// + +// La entrada y salida de C++ utiliza flujos (streams) +// cin, cout, y cerr representan a stdin, stdout, y stderr. +// << es el operador de inserción >> es el operador de extracción. + + +#include <iostream> // Incluir para el flujo de entrada/salida + +using namespace std; // Los streams estan en std namespace (libreria estandar) + +int main() +{ + int myInt; + + // Imprime a la stdout (o terminal/pantalla) + cout << "Ingresa tu número favorito:\n"; + // Toma una entrada + cin >> myInt; + + // cout puede también ser formateado + cout << "Tu número favorito es " << myInt << "\n"; + // imprime "Tu número favorito es <myInt>" + + cerr << "Usado para mensajes de error"; +} +//////////////////// +// Cadenas (Strings) +//////////////////// + +// Las cadenas en C++ son objetos y tienen muchas funciones +#include <string> + +using namespace std; // Strings también estan en namespace std + +string myString = "Hola"; +string myOtherString = " Mundo"; + +// + es usado para concatenar. +cout << myString + myOtherString; // "Hola Mundo" + +cout << myString + " Tu"; // "Hola Tu" + +// Las cadenas en C++ son mutables y tienen valor semántico. +myString.append(" Perro"); +cout << myString; // "Hola Perro" + + +////////////// +// Referencias +////////////// + +// Además de punteros como los de C, +// C++ tiene _references_. +// Estos tipos de puntero no pueden ser reasignados una vez establecidos +// Y no pueden ser nulos. +// También tienen la misma sintaxis que la propia variable: +// No es necesaria * para eliminar la referencia y +// & (dirección) no se utiliza para la asignación. + +using namespace std; + +string foo = "Yo soy foo"; +string bar = "Yo soy bar"; + +string& fooRef = foo; // Crea una referencia a foo. +fooRef += ". Hola!"; // Modifica foo través de la referencia +cout << fooRef; // Imprime "Yo soy foo. Hola!" + +// No trate de reasignar "fooRef". Esto es lo mismo que "foo = bar", y +// foo == "Yo soy bar" +// después de esta linea. +fooRef = bar; + +const string& barRef = bar; // Crea una referencia constante a bar. +// Como en C, los valores constantes (y punteros y referencias) no pueden ser +// modificados. +barRef += ". Hola!"; // Error, referencia constante no puede ser modificada. + +// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un +// concepto llamado objeto temporal. Supongamos que tenemos el siguiente código: +string tempObjectFun() { ... } +string retVal = tempObjectFun(); + +// Lo que pasa en la segunda línea es en realidad: +// - Un objeto de cadena es retornado desde tempObjectFun +// - Una nueva cadena se construye con el objeto devuelto como argumento al +// constructor +// - El objeto devuelto es destruido +// El objeto devuelto se llama objeto temporal. Objetos temporales son +// creados cada vez que una función devuelve un objeto, y es destruido en el +// fin de la evaluación de la expresión que encierra (Bueno, esto es lo que la +// norma dice, pero los compiladores están autorizados a cambiar este +// comportamiento. Busca "return value optimization" para ver mas detalles). +// Así que en este código: +foo(bar(tempObjectFun())) + +// Suponiendo que foo y bar existen, el objeto retornado de tempObjectFun es +// pasado al bar, y se destruye antes de llamar foo. + +// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo +// de la expresión encerrada" es si un objeto temporal se une a una +// referencia constante, en cuyo caso su vida se extiende al ámbito actual: + +void constReferenceTempObjectFun() { + // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta + // función. + const string& constRef = tempObjectFun(); + ... +} + +// Otro tipo de referencia introducida en C ++ 11 es específicamente para +// objetos temporales. No se puede tener una variable de este tipo, pero tiene +// prioridad en resolución de sobrecarga: + +void someFun(string& s) { ... } // Referencia regular +void someFun(string&& s) { ... } // Referencia a objeto temporal + +string foo; +someFun(foo); // Llama la función con referencia regular +someFun(tempObjectFun()); // Llama la versión con referencia temporal + +// Por ejemplo, puedes ver estas dos versiones de constructores para +// std::basic_string: +basic_string(const basic_string& other); +basic_string(basic_string&& other); + +// La idea es que si estamos construyendo una nueva cadena de un objeto temporal +// (que va a ser destruido pronto de todos modos), podemos tener un constructor +// mas eficiente que "rescata" partes de esa cadena temporal. Usted verá este +// Concepto denominado "movimiento semántico". + +//////////////////////////////////////////// +// Clases y programación orientada a objetos +//////////////////////////////////////////// + +// Primer ejemplo de clases +#include <iostream> + +// Declara una clase. +// Las clases son usualmente declaradas en archivos de cabeceras (.h o .hpp) +class Dog { + // Variables y funciones de la clase son privados por defecto. + std::string name; + int weight; + +// Todos los miembros siguientes de este son públicos +// Hasta que se encuentre "private" o "protected". +// All members following this are public +// until "private:" or "protected:" is found. +public: + + // Constructor por defecto + Dog(); + + // Declaraciones de funciones de la clase (implementaciones a seguir) + // Nota que usamos std::string aquí en lugar de colocar + // using namespace std; + // arriba. + // Nunca ponga una declaración "using namespace" en un encabezado. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + // Funciones que no modifican el estado del objeto + // Deben marcarse como const. + // Esto le permite llamarlas si se envia una referencia constante al objeto. + // También tenga en cuenta que las funciones deben ser declaradas + // explícitamente como _virtual_ para que sea reemplazada en las clases + // derivadas. + // Las funciones no son virtuales por defecto por razones de rendimiento. + virtual void print() const; + + // Las funciones también se pueden definir en el interior + // del cuerpo de la clase. + // Funciones definidas como tales están entre líneas automáticamente. + void bark() const { std::cout << name << " barks!\n"; } + + // Junto a los constructores, C++ proporciona destructores. + // Estos son llamados cuando un objeto se elimina o está fuera del ámbito. + // Esto permite paradigmas potentes como RAII + // (mira abajo) + // El destructor debe ser virtual si una clase es dervada desde el; + // Si no es virtual, entonces la clase derivada destructor + // No será llamada si el objeto se destruye a través de una referencia de + // la clase base o puntero. + virtual ~Dog(); + + + +}; // Un punto y coma debe seguir la definición de clase. + +// Las funciones de una clase son normalmente implementados en archivos .cpp. +Dog::Dog() +{ + std::cout << "Un perro ha sido construido\n"; +} + +// Objetos (tales como cadenas) deben ser pasados por referencia +// Si los estas modificando o referencia constante en caso contrario. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Nota que "virtual" sólo se necesita en la declaración, no en la definición. +void Dog::print() const +{ + std::cout << "El perro es " << name << " y pesa " << weight << "kg\n"; +} + +Dog::~Dog() +{ + cout << "Adiós " << name << "\n"; +} + +int main() { + Dog myDog; // imprime "Un perro ha sido construido" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.print(); // imprime "El perro es Barkley y pesa 10 kg" + return 0; +} // imprime "Adiós Barkley" + +// Herencia: + +// Esta clase hereda todo lo público y protegido de la clase Dog +class OwnedDog : public Dog { + + void setOwner(const std::string& dogsOwner); + + // Reemplaza el comportamiento de la función de impresión + // de todos los OwnedDogs. Mira + // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // Para una introducción más general si no está familiarizado con el + // polimorfismo de subtipo. + // La palabra clave override es opcional, pero asegura que estás + // reemplazando el método de una clase base. + void print() const override; + +private: + std::string owner; +}; + +// Mientras tanto, en el archivo .cpp correspondiente: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Llama a la función de impresión en la clase base Dog + std::cout << "El perro es de " << owner << "\n"; + // Imprime "El perro es <name> y pesa <weight>" + // "El perro es de <owner>" +} + +//////////////////////////////////////////// +// Inicialización y sobrecarga de operadores +//////////////////////////////////////////// + +// En C ++ se puede sobrecargar el comportamiento +// de los operadores como +, -, *, /, etc. +// Esto se hace mediante la definición de una función que es llamada +// cada vez que se utiliza el operador. + +#include <iostream> +using namespace std; + +class Point { +public: + // Las variables de la clase pueden dar valores por defecto de esta manera. + double x = 0; + double y = 0; + + // Define un constructor por defecto que no hace nada + // pero inicializa el punto al valor por defecto (0, 0) + Point() { }; + + // The following syntax is known as an initialization list + // and is the proper way to initialize class member values + Point (double a, double b) : + x(a), + y(b) + { /* No hace nada excepto inicializar los valores */ } + + // Sobrecarga el operador + + Point operator+(const Point& rhs) const; + + // Sobrecarga el operador += + Point& operator+=(const Point& rhs); + + // También tendría sentido añadir los operadores - y -=, + // Pero vamos a omitirlos por razones de brevedad. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Crea un nuevo punto que es la suma de este y rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // Llama al operador + de Point + // Point llama la función + con right como parámetro + Point result = up + right; + // Prints "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +///////////////////////// +// Plantillas (Templates) +///////////////////////// + +// Las plantillas en C++ se utilizan sobre todo en la programación genérica, +// a pesar de que son mucho más poderoso que los constructores genéricos +// en otros lenguajes. Ellos también soportan especialización explícita y +// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje +// funcional Turing-completo incrustado en C ++! + +// Empezamos con el tipo de programación genérica que podría estar +// familiarizado. +// Para definir una clase o función que toma un parámetro de tipo: +template<class T> +class Box { +public: + // En este caso, T puede ser usado como cualquier otro tipo. + void insert(const T&) { ... } +}; + +// Durante la compilación, el compilador realmente genera copias de cada +// plantilla con parámetros sustituidos, por lo que la definición completa +// de la clase debe estar presente en cada invocación. +// Es por esto que usted verá clases de plantilla definidas +// Enteramente en archivos de cabecera. + +//Para crear una instancia de una clase de plantilla en la pila: +Box<int> intBox; + +y puedes utilizarlo como era de esperar: +intBox.insert(123); + +// Puedes, por supuesto, anidar plantillas: +Box<Box<int> > boxOfBox; +boxOfBox.insert(intBox); + +// Hasta C++11, había que colocar un espacio entre los dos '>'s, +// de lo contrario '>>' serían analizados como el operador de desplazamiento +// a la derecha. + + +// A veces verás +// template<typename T> +// en su lugar. La palabra clave "class" y las palabras clave "typename" son +// mayormente intercambiables en este caso. Para la explicación completa, mira +// http://en.wikipedia.org/wiki/Typename +// (sí, esa palabra clave tiene su propia página de Wikipedia). + +// Del mismo modo, una plantilla de función: +template<class T> +void barkThreeTimes(const T& input) +{ + input.bark(); + input.bark(); + input.bark(); +} + +// Observe que no se especifica nada acerca de los tipos de parámetros aquí. +// El compilador generará y comprobará cada invocación de la plantilla, +// por lo que la función anterior funciona con cualquier tipo "T" +// que tenga un método 'bark' constante! + + +Dog fluffy; +fluffy.setName("Fluffy") +barkThreeTimes(fluffy); // Imprime "Fluffy barks" 3 veces. + +Los parámetros de la plantilla no tienen que ser las clases: +template<int Y> +void printMessage() { + cout << "Aprende C++ en " << Y << " minutos!" << endl; +} + +// Y usted puede especializar explícitamente plantillas +// para código más eficiente. +// Por supuesto, la mayor parte del mundo real que utiliza una especialización +// no son tan triviales como esta. +// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) +// como plantilla incluso si ha especificado de forma explícita todos +// los parámetros. + +template<> +void printMessage<10>() { + cout << "Aprende C++ rapido en solo 10 minutos!" << endl; +} + +printMessage<20>(); // Prints "Aprende C++ en 20 minutos!" +printMessage<10>(); // Prints "Aprende C++ rapido en solo 10 minutos!" + + +///////////////////// +// Manejador de excepciones +///////////////////// + +// La biblioteca estándar proporciona algunos tipos de excepción +// (mira http://en.cppreference.com/w/cpp/error/exception) +// pero cualquier tipo puede ser lanzado como una excepción +#include <exception> +#include <stdexcept> + +//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser +// capturados por los siguientes manejadores _catch_. +try { + // No asignar excepciones en el heap usando _new_. + throw std::runtime_error("Ocurrió un problema"); +} + +// Captura excepciones por referencia const si son objetos +catch (const std::exception& ex) +{ + std::cout << ex.what(); +} +******************************************************************************** +// Captura cualquier excepción no capturada por bloques _catch_ anteriores +catch (...) +{ + std::cout << "Excepción desconocida capturada"; + throw; // Re-lanza la excepción +} + +/////// +// RAII +/////// + +// RAII significa "Resource Acquisition Is Initialization" +// (Adquisición de recursos es inicialización). +// A menudo se considera el paradigma más poderoso en C++ +// Y el concepto es simple: un constructor de un objeto +// Adquiere recursos de ese objeto y el destructor les libera. + +// Para entender cómo esto es útil, +// Considere una función que utiliza un identificador de archivo C: +void doSomethingWithAFile(const char* filename) +{ + // Para empezar, asuma que nada puede fallar. + + FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Cierra el manejador de archivos +} + +// Por desgracia, las cosas se complican rápidamente por el control de errores. +// Supongamos que fopen puede fallar, y que doSomethingWithTheFile y +// DoSomethingElseWithIt retornan códigos de error si fallan. +// (Excepciones son la mejor forma de manejar los fallos, +// pero algunos programadores, especialmente los que tienen un fondo C, +// estan en desacuerdo sobre la utilidad de las excepciones). +// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador +// del archivo si se ha producido un problema. +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura + if (fh == nullptr) // El puntero retornado es nulo o falla. + return false; // Reporta el fallo a quien hizo el llamado. + + // Asume que cada función retorna falso si falla + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Cierre el manejador de archivo para que no se filtre. + return false; // Propaga el error. + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Cierre el manejador de archivo para que no se filtre. + return false; // Propaga el error. + } + + fclose(fh); // Cierre el archivo. + return true; // Indica que todo funcionó correctamente. +} + +// Programadores C suelen limpiar esto un poco usando goto: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + return false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Cierre el archivo. + return true; // Indica que todo funcionó correctamente. + +failure: + fclose(fh); + return false; // Propagate el error +} + +// Si las funciones indican errores mediante excepciones, +// Las cosas son un poco más claras, pero pueden optimizarse mas. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abrir el archivo en modo lectura + if (fh == nullptr) + throw std::runtime_error("No puede abrirse el archivo."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Asegúrese de cerrar el archivo si se produce un error. + throw; // Luego vuelve a lanzar la excepción. + } + + fclose(fh); // Cierra el archivo +} + +// Compare esto con el uso de la clase de flujo de archivos de C++ (fstream) +// fstream utiliza su destructor para cerrar el archivo. +// Los destructores son llamados automáticamente +// cuando un objeto queda fuera del ámbito. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream es la abreviatura de el input file stream + std::ifstream fh(filename); // Abre el archivo + + // Hacer algo con el archivo + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // El archivo se cierra automáticamente aquí por el destructor + + +// Esto tiene ventajas _enormes_: +// 1. No importa lo que pase, +// El recurso (en este caso el manejador de archivo) será limpiado. +// Una vez que escribes el destructor correctamente, +// Es _imposible_ olvidar cerrar el identificador y permitir +// fugas del recurso. +// 2. Tenga en cuenta que el código es mucho más limpio. +// El destructor se encarga de cerrar el archivo detrás de cámaras +// Sin que tenga que preocuparse por ello. +// 3. El código es seguro. +// Una excepción puede ser lanzado en cualquier lugar de la función +// y la limpieza ocurrirá. + +// Todo el código idiomático C++ utiliza RAII ampliamente para todos los +// recursos. +// Otros ejemplos incluyen +// - Memoria usando unique_ptr y shared_ptr +// - Contenedores (Containers) - la biblioteca estándar linked list, +// vector (es decir, array con auto-cambio de tamaño), hash maps, etc. +// Destruimos todos sus contenidos de forma automática +// cuando quedan fuera del ámbito. +// - Mutex utilizando lock_guard y unique_lock + + +///////////////////// +// Cosas divertidas +///////////////////// + +// Aspectos de C ++ que pueden sorprender a los recién llegados +// (e incluso algunos veteranos). +// Esta sección es, por desgracia, salvajemente incompleta; +// C++ es uno de los lenguajes con los que mas facil te disparas en el pie. + +// Tu puedes sobreescribir métodos privados! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // Sobreescribe Foo::bar! +}; + + +// 0 == false == NULL (La mayoria de las veces)! +bool* pt = new bool; +*pt = 0; // Establece los puntos de valor de 'pt' en falso. +pt = 0; // Establece 'pt' al apuntador nulo. Ambas lineas compilan sin error. + +// nullptr se supone que arregla un poco de ese tema: +int* pt2 = new int; +*pt2 = nullptr; // No compila +pt2 = nullptr; // Establece pt2 como null. + +// Hay una excepción para los valores bool. +// Esto es para permitir poner a prueba punteros nulos con if (!ptr), +// pero como consecuencia se puede asignar nullptr a un bool directamente! +*pt = nullptr; // Esto todavía compila, a pesar de que '*pt' es un bool! + +// '=' != '=' != '='! +// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) +// copia del constructor. +Foo f2; +Foo f1 = f2; + +// Llama Foo::Foo(const Foo&) o variante, pero solo copia el 'Foo' parte de +// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este +// comportamiento horrible se llama "Corte de objetos." +FooSub fooSub; +Foo f1 = fooSub; + +// Llama a Foo::operator=(Foo&) o variantes. +Foo f1; +f1 = f2; + + +// Cómo borrar realmente un contenedor: +class Foo { ... }; +vector<Foo> v; +for (int i = 0; i < 10; ++i) + v.push_back(Foo()); +// La siguiente línea establece el tamaño de v en 0, +// pero los destructores no son llamados y los recursos no se liberan! + +v.empty(); +v.push_back(Foo()); // Nuevo valor se copia en el primer Foo que insertamos + +// En verdad destruye todos los valores en v. +// Consulta la sección acerca de los objetos temporales para la +// explicación de por qué esto funciona. +v.swap(vector<Foo>()); + +``` +Otras lecturas: + +Una referencia del lenguaje hasta a la fecha se puede encontrar en +<http://cppreference.com/w/cpp> + +Recursos adicionales se pueden encontrar en <http://cplusplus.com> diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown new file mode 100644 index 00000000..5d3aae0c --- /dev/null +++ b/es-es/c-es.html.markdown @@ -0,0 +1,425 @@ +--- +language: c +filename: learnc-es.c +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Francisco García", "http://flaskbreaker.tumblr.com/"] +lang: es-es +--- + +¡Ah!, C. Aun hoy en día sigue siendo el lenguaje por excelencia de la +computación moderna de alto rendimiento. + +C es el lenguaje de más bajo nivel que la mayoría de los programadores +llegarán a usar, pero lo compensa de sobra con pura velocidad. Solo +ten en cuenta el manejo manual de memoria y te llevará tan lejos como +necesites. + +```c +// Los comentarios de una sola línea comienzan con // + +/* +Los comentarios multilínea tienen este aspecto. +*/ + +// Importa cabeceras con #include +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// Declara por adelantado las armaduras de las funciones en un archivo .h, +// o al principio de tu archivo .c . +void function_1(); +void function_2(); + +// El punto de entrada de tu programa es una función llamada main con +// retorno de tipo entero (integer). +int main() { + +// Muestra la salida usando printf, para el "formato print" +// %d es un entero, \n es una nueva línea +printf("%d\n", 0); // => Muestra 0 +// Todas las sentencias deben terminar con un punto y coma. + +/////////////////////////////////////// +// Tipos +/////////////////////////////////////// + +// Tienes que declarar una variable antes de usarla. La declaración de una +// variable necesites que especifiques su tipo; el tipo de una variable +// determina su tamaño en bytes. + +// 'ints' (enteros) son normalmente de 4 bytes +int x_int = 0; + +// 'shorts' son normalmente de 2 bytes +short x_short = 0; + +// 'chars' son fijo de 1 byte +char x_char = 0; +char y_char = 'y'; // Los caracteres literales se entrecomillan con '' + +// 'longs' son a menudo de 4 a 8 bytes; 'long longs' son fijo de por lo +// menos 64 bits +long x_long = 0; +long long x_long_long = 0; + +// 'floats' son normalmente números de coma flotante de 32 bits +float x_float = 0.0; + +// 'doubles' son normalmente números de coma flotante de 64 bits +double x_double = 0.0; + +// Todos los tipos enteros pueden ser 'unsigned'. Esto significa que no +// pueden ser negativos, pero el valor máximo de una variable 'unsigned' +// es mayor que el de una no 'unsigned' del mismo tamaño. +unsigned char ux_char; +unsigned short ux_short; +unsigned int ux_int; +unsigned long long ux_long_long; + +// Todos menos 'char', que es siempre de 1 byte, varían el tamaño +// dependiendo de tu máquina. sizeof(T) te dice el tamaño de una variable +// de tipo T en bytes por lo que podemos expresar el tamaño de estos tipos +// portatilmente. +// Por ejemplo, +printf("%lu\n", sizeof(int)); // => 4 (en máquinas con 'words' de 4 bytes) + +// Los arrays deben ser inicializados con un tamaño concreto. +char my_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes +int my_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes + // (suponiendo que tenemos 'words' de 4-byte) + + +// Puedes inicializar un array a 0 así: +char my_array[20] = {0}; + +// Indexar un array es como en otros lenguajes -o, más bien, otros +// lenguajes son como C- +my_array[0]; // => 0 + +// Los arrays varían; ¡son sólo memoria! +my_array[1] = 2; +printf("%d\n", my_array[1]); // => 2 + +// Las cadenas (strings) son sólo arrays de 'chars' (caracteres) +// terminados en un byte NUL (0x00), representado en las cadenas como el +// carácter especial '\0'. +// (No tenemos porqué añadir el byte nulo en cadenas literales; el +// compilador lo añade al final por nosotros.) +char a_string[20] = "Esto es una cadena"; +printf("%s\n", a_string); // %s se sutituye por una cadena. + +/* +Te habrás dado cuenta de que a_string es solo de 18 caracteres. +El 'char' #19 es el byte nulo. +El 'char' #20 es de valor indefinido. +*/ + +printf("%d\n", a_string[18]); // => 0 + +/////////////////////////////////////// +// Operadores +/////////////////////////////////////// + +int i1 = 1, i2 = 2; // Forma corta de declaración múltiple +float f1 = 1.0, f2 = 2.0; + +// La aritmética es sencilla +i1 + i2; // => 3 +i2 - i1; // => 1 +i2 * i1; // => 2 +i1 / i2; // => 0 (0.5, pero es truncado tras el 0) + +f1 / f2; // => 0.5, más o menos épsilon +// Módulo está también +11 % 3; // => 2 + +// Los operadores de comparación te resultaran familiares, pero no hay +// booleanos en C. Usamos enteros (ints) en su lugar. 0 es falso, +// cualquier otra cosa es verdadero. (Los operadores de comparación +// siempre devuelven 0 o 1) +3 == 2; // => 0 (Falso) +3 != 2; // => 1 (Verdadero) +3 > 2; // => 1 +3 < 2; // => 0 +2 <= 2; // => 1 +2 >= 2; // => 1 + +// La lógica funiona en enteros +!3; // => 0 (not lógico) +!0; // => 1 +1 && 1; // => 1 (and lógico) +0 && 1; // => 0 +0 || 1; // => 1 (or lógico) +0 || 0; // => 0 + +// ¡Operadores de bits! +~0x0F; // => 0xF0 (Negación) +0x0F & 0xF0; // => 0x00 (AND) +0x0F | 0xF0; // => 0xFF (OR) +0x04 ^ 0x0F; // => 0x0B (XOR) +0x01 << 1; // => 0x02 (desplazar hacia la izquierda (por 1)) +0x02 >> 1; // => 0x01 (desplazar hacia la derecha (por 1)) + +/////////////////////////////////////// +// Estructuras de Control +/////////////////////////////////////// + +if (0) { + printf("Yo nunca ocurro\n"); +} else if (0) { + printf("Yo tampoco ocurro nunca\n"); +} else { + printf("Yo me muestro\n"); +} + +// Mientras el bucle exista +int ii = 0; +while (ii < 10) { + printf("%d, ", ii++); // ii++ incrementa ii en uno, después de usar su valor. +} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + +printf("\n"); + +int kk = 0; +do { + printf("%d, ", kk); +} while (++kk < 10); // ++kk incrementa kk en uno, antes de usar su valor. +// => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + +printf("\n"); + +// Bucles 'for' también +int jj; +for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); +} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + +printf("\n"); + +/////////////////////////////////////// +// Cambios de Tipo +/////////////////////////////////////// + +// Cada valor en C tiene un tipo, pero tu puedes ingresar un valor en +// otro tipo si quieres. + +int x_hex = 0x01; // Puedes asignar hexadecimales a variables + +// El cambio de tipos intentará mantener sus valores numéricos +printf("%d\n", x_hex); // => Muestra 1 +printf("%d\n", (short) x_hex); // => Muestra 1 +printf("%d\n", (char) x_hex); // => Muestra 1 + +// Los tipos se desbordan sin aviso +printf("%d\n", (char) 257); // => 1 (El valor máximo de un 'char' es 255) + +// Los tipos enteros puden cambiarse a tipos de coma flotante, y viceversa +printf("%f\n", (float)100); // %f se sustituye por un 'float' +printf("%lf\n", (double)100); // %lf se sustituye por un 'double' +printf("%d\n", (char)100.0); + +/////////////////////////////////////// +// Punteros +/////////////////////////////////////// + +// Un puntero es una variable declarada para almacenar una dirección de +// memoria. Su declaración además nos dirá el tipo de dato al que apunta. +// Puedes obtener la dirección de memoria de tus variables, y después +// enlazarlas con ellos. + +int x = 0; +printf("%p\n", &x); // Usa & para obtener la dirección de una variable. +// (%p se sustituye por un puntero) +// => Muestra alguna dirección de memoria; + +// Los tipos de puntero terminan con * en su declaración +int* px; // px es un puntero a un 'int' +px = &x; // Almacena la dirección de x en px +printf("%p\n", px); // => Muestra alguna dirección de memoria + +// Para obtener el valor de la dirección a la que apunta un puntero, pon +// * delante para desreferenciarle. +printf("%d\n", *px); // => Muestra 0, el valor de x y de la dirección a la + // que apunta px + +// También puedes cambiar el valor al que está apuntando el puntero. +// Tenemos que meter la desreferencia entre paréntesis porque ++ tiene +// prioridad frente a *. +(*px)++; // Incrementa el valor al que apunta px en 1 +printf("%d\n", *px); // => Muestra 1 +printf("%d\n", x); // => Muestra 1 + +int x_array[20]; // Los arrays son una buena manera de distribuir bloques +int xx; // continuos de memoria. +for (xx=0; xx<20; xx++) { + x_array[xx] = 20 - xx; +} // Inicializa x_array a 20, 19, 18,... 2, 1 + +// Declara un puntero de tipo 'int' y lo inicializa para apuntar a x_array +int* x_ptr = x_array; +// x_ptr ahira apunta al primer elemento del 'array' (el entero 20). +// Esto funciona porque las 'arrays' actualmente son solo punteros a su +// primer elemento. + +// Los 'arrays' son punteros a su primer elemento. +printf("%d\n", *(x_ptr)); // => Muestra 20 +printf("%d\n", x_array[0]); // => Muestra 20 + +// Los punteros aumentan y disminuyen en función de su tipo. +printf("%d\n", *(x_ptr + 1)); // => Muestra 19 +printf("%d\n", x_array[1]); // => Muestra 19 + +// Puedes también asigner dinamicamente bloques contiguos de memoria con +// la función malloc de la librería estándard, que toma un entero como +// argumento representando el número de bytes a asignar de la pila. +int* my_ptr = (int*) malloc(sizeof(int) * 20); +for (xx=0; xx<20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx funcionaría también aquí +} // Inicializa la memoria a 20, 19, 18, 17... 2, 1 (como 'ints') + +// Desreferenciando la memoria que no has asignado te dará resultados +// impredecibles +printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what? + +// Cuando hayas acabado con el bloque de memoría malloc, necesitas +// liberarlo o sino nadie más podrá usarlo hasta que tu programa se cierre +free(my_ptr); + +// Las cadenas pueden ser 'arrays' de chars, pero normalmente se +// representan con punteros 'char': +char* my_str = "This is my very own string"; + +printf("%c\n", *my_str); // => 'T' + +function_1(); +} // fin de la función main + +/////////////////////////////////////// +// Funciones +/////////////////////////////////////// + +// Sintexis de la declaración de funciones: +// <tipo de retorno> <nombre>(<argumentos>) + +int add_two_ints(int x1, int x2){ + return x1 + x2; // Usa 'return' para dar una salida +} + +/* +Las funciones son de paso por valor, pero puedes hacer tus propias +referencias con punteros de manera que las funciones puedan cambiar sus +valores. + +Ejemplo: invertidor de cadenas in-situ +*/ + +// Una función 'void' no retorna valor +void str_reverse(char* str_in){ + char tmp; + int ii=0, len = strlen(str_in); // Strlen es parte de la librería + for(ii=0; ii<len/2; ii++){ // estándard + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // ii-th último 'char' + str_in[len - ii - 1] = tmp; + } +} + +/* +char c[] = "Esto es una prueba."; +str_reverse(c); +printf("%s\n", c); // => ".abeurp anu se otsE" +*/ + +/////////////////////////////////////// +// Definición de tipos y estructuras +/////////////////////////////////////// + +// Los 'Typedefs' pueden ser utilizados para crear alias de tipos. +typedef int my_type; +my_type my_type_var = 0; + +// Las estructuras son sólo grupos de datos. +struct rectangle { + int width; + int height; +}; + + +void function_1(){ + + struct rectangle my_rec; + + // Utiliza los miembros de una estructura con . + my_rec.width = 10; + my_rec.height = 20; + + // Puedes declarar punteros a estructuras + struct rectangle* my_rec_ptr = &my_rec; + + // Usa la desreferencia para modificar sus miembros... + (*my_rec_ptr).width = 30; + + // ... o usa la abreviatura -> + my_rec_ptr->height = 10; // Lo mismo que (*my_rec_ptr).height = 10; +} + +// Puedes aplicar un 'typedef' a una estructura por conveniencía. +typedef struct rectangle rect; + +int area(rect r){ + return r.width * r.height; +} + +/////////////////////////////////////// +// Punteros a Funciones +/////////////////////////////////////// +/* +En tiempo de ejecución, las funciones se localizan en unas direcciones de +memoria concretas. Los punteros a funciones son como cualquier otro +puntero (almacenan una dirección de memoria), pero pueden ser usados para +utilizar funciones directamente, o para pasar 'handlers' (o funciones +'callback') por todos lados. +Sin embargo, la sintaxis de definición parecera confusa al principio. + +Ejemplo: usar str_reverse desde un puntero +*/ +void str_reverse_through_pointer(char * str_in) { + // Define un puntero a una función, llamado f. + void (*f)(char *); + // La armadura debe coincidir exactamente con al función objetivo. + + // Assigna la dirección de la función (determinado en tiempo de ejecuión) + f = &str_reverse; + + // Llamando la función desde el puntero + (*f)(str_in); + + // Esta es una alternativa para llamarla pero con una sintaxis igual de válida. + // f(str_in); +} + +/* +Tanto tiempo como las armaduras de las funciones coincidan, podrás asignar +cualquier función al mismo puntero. +Los punteros a funciones son normalmente envueltos en 'typedef' para +simplificar su legibilidad, como sigue: +*/ + +typedef void (*my_fnp_type)(char *); + +// Es usado para declarar la variable puntero actual: +// ... +// my_fnp_type f; + +``` + +## Otras lecturas + +Lo mejor que puedes en contrar es una copia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language) + +Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/) + +Aparte de eso, Google es tu amigo. diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown new file mode 100644 index 00000000..150d0bb2 --- /dev/null +++ b/es-es/clojure-es.html.markdown @@ -0,0 +1,393 @@ +--- +language: clojure +filename: learnclojure-es.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Antonio Hernández Blas", "https://twitter.com/nihilipster"] + - ["Guillermo Vayá Pérez", "http://willyfrog.es"] +lang: es-es +--- + +Clojure es un lenguaje de la familia Lisp desarrollado sobre la Máquina Virtual +de Java. Tiene un énfasis mayor en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura +que Common Lisp, pero incluyendo la posibilidad de usar [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular +el estado según se presente. + +Esta combinación le permite gestionar la concurrencia de manera muy sencilla +y a menudo automáticamente. + +(Necesitas la versión de Clojure 1.2 o posterior) + + +```clojure +; Los comentatios comienzan con punto y coma. + +; Clojure se escribe mediante "forms" (patrones), los cuales son +; listas de objectos entre paréntesis, separados por espacios en blanco. + +; El "reader" (lector) de Clojure asume que el primer objeto es una +; función o una macro que se va a llamar, y que el resto son argumentos. + +; El primer form en un archivo debe ser ns, para establecer el namespace (espacio de +; nombres) +(ns learnclojure) + +; Algunos ejemplos básicos: + +; str crea una cadena de caracteres a partir de sus argumentos +(str "Hello" " " "World") ; => "Hello World" + +; Las operaciones matemáticas son sencillas +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; La igualdad es = +(= 1 1) ; => true +(= 2 1) ; => false + +; También es necesaria la negación para las operaciones lógicas +(not true) ; => false + +; Cuando se anidan Los patrones, estos funcionan de la manera esperada +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; Tipos +;;;;;;;;;;;;; + +; Clojure usa los tipos de objetos de Java para booleanos, strings (cadenas de +; caracteres) y números. +; Usa class para saber de qué tipo es. +(class 1); Los enteros son java.lang.Long por defecto +(class 1.); Los numeros en coma flotante son java.lang.Double +(class ""); Los strings van entre comillas dobles, y son +; son java.lang.String +(class false); Los Booleanos son java.lang.Boolean +(class nil); El valor "null" se escribe nil + +; Si quieres crear una lista de datos, precedela con una comilla +; simple para evitar su evaluación +'(+ 1 2) ; => (+ 1 2) +; (que es una abreviatura de (quote (+ 1 2)) ) + +; Puedes evaluar una lista precedida por comilla con eval +(eval '(+ 1 2)) ; => 3 + +; Colecciones & Secuencias +;;;;;;;;;;;;;;;;;;; + +; Las Listas están basadas en las listas enlazadas, mientras que los Vectores en +; arrays. +; ¡Los Vectores y las Listas también son clases de Java! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; Una lista podría ser escrita como (1 2 3), pero debemos ponerle una +; comilla simple delante para evitar que el reader piense que es una función. +; Además, (list 1 2 3) es lo mismo que '(1 2 3) + +; Las "Colecciones" son solo grupos de datos +; Tanto las listas como los vectores son colecciones: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; Las "Secuencias" (seqs) son descripciones abstractas de listas de datos. +; Solo las listas son seqs. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; Una seq solo necesita proporcionar una entrada cuando es accedida. +; Así que, las seqs pueden ser perezosas -- pueden establecer series infinitas: +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (una serie infinita) +(take 4 (range)) ; (0 1 2 3) + +; Usa cons para agregar un elemento al inicio de una lista o vector +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; conj agregará un elemento a una colección en la forma más eficiente. +; Para listas, se añade al inicio. Para vectores, al final. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; Usa concat para concatenar listas o vectores +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; Usa filter y map para actuar sobre colecciones +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; Usa reduce para combinar sus elementos +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; reduce puede tener un argumento indicando su valor inicial. +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; Funciones +;;;;;;;;;;;;;;;;;;;;; + +; Usa fn para crear nuevas funciones. Una función siempre devuelve +; su última expresión +(fn [] "Hello World") ; => fn + +; (Necesitas rodearlo con paréntesis para invocarla) +((fn [] "Hello World")) ; => "Hello World" + +; Puedes crear una var (variable) mediante def +(def x 1) +x ; => 1 + +; Asigna una función a una var +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; Puedes defn como atajo para lo anterior +(defn hello-world [] "Hello World") + +; El [] es el vector de argumentos de la función. +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; Otra abreviatura para crear funciones es: +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; Puedes tener funciones multi-variadic: funciones con un numero variable de +; argumentos +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; Las funciones pueden usar argumentos extras dentro de un seq utilizable en la función +(defn count-args [& args] + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" + +; Y puedes mezclarlos con el resto de argumentos declarados de la función. +(defn hello-count [name & args] + (str "Hello " name ", you passed " (count args) " extra args")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" + + +; Mapas +;;;;;;;;;; + +; Mapas de Hash y mapas de arrays comparten una misma interfaz. Los mapas de Hash +; tienen búsquedas más rápidas pero no mantienen el orden de las claves. +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; Los mapas de arrays se convertidos en mapas de Hash en la mayoría de +; operaciones si crecen mucho, por lo que no debes preocuparte. + +; Los mapas pueden usar cualquier tipo para sus claves, pero generalmente las +; keywords (palabras clave) son lo habitual. +; Las keywords son parecidas a cadenas de caracteres con algunas ventajas de eficiencia +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; Por cierto, las comas son equivalentes a espacios en blanco y no hacen +; nada. + +; Recupera un valor de un mapa tratandolo como una función +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; ¡Las keywords pueden ser usadas para recuperar su valor del mapa, también! +(:b keymap) ; => 2 + +; No lo intentes con strings. +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; Si preguntamos por una clave que no existe nos devuelve nil +(stringmap "d") ; => nil + +; Usa assoc para añadir nuevas claves a los mapas de Hash +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; Pero recuerda, ¡los tipos de Clojure son inmutables! +keymap ; => {:a 1, :b 2, :c 3} + +; Usa dissoc para eliminar llaves +(dissoc keymap :a :b) ; => {:c 3} + +; Conjuntos +;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; Añade un elemento con conj +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; Elimina elementos con disj +(disj #{1 2 3} 1) ; => #{2 3} + +; Comprueba su existencia usando el conjunto como una función: +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; Hay más funciones en el namespace clojure.sets + +; Patrones útiles +;;;;;;;;;;;;;;;;; + +; Las construcciones lógicas en clojure son macros, y presentan el mismo aspecto +; que el resto de forms. +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; Usa let para crear un binding (asociación) temporal +(let [a 1 b 2] + (> a b)) ; => false + +; Agrupa expresiones mediante do +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; Las funciones tienen implicita la llamada a do +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; Y el let también +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; Módulos +;;;;;;;;;;;;;;; + +; Usa use para obtener todas las funciones del módulo +(use 'clojure.set) + +; Ahora podemos usar más operaciones de conjuntos +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; Puedes escoger un subgrupo de funciones a importar, también +(use '[clojure.set :only [intersection]]) + +; Usa require para importar un módulo +(require 'clojure.string) + +; Usa / para llamar a las funciones de un módulo +; Aquí, el módulo es clojure.string y la función es blank? +(clojure.string/blank? "") ; => true + +; Puedes asignarle una abreviatura a un modulo al importarlo +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (#"" es una expresión regular) + +; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombre +; usando :require, +; No necesitas preceder con comilla simple tus módulos si lo haces de esta +; forma. +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java tiene una enorme librería estándar, por lo que resulta util +; aprender como interactuar con ella. + +; Usa import para cargar un módulo de java +(import java.util.Date) + +; Puedes importar desde un ns también. +(ns test + (:import java.util.Date + java.util.Calendar)) + +; Usa el nombre de la clase con un "." al final para crear una nueva instancia +(Date.) ; <un objeto Date> + +; Usa "." para llamar a métodos o usa el atajo ".método" +(. (Date.) getTime) ; <un timestamp> +(.getTime (Date.)) ; exactamente la misma cosa + +; Usa / para llamar métodos estáticos. +(System/currentTimeMillis) ; <un timestamp> (System siempre está presente) + +; Usa doto para hacer frente al uso de clases (mutables) más tolerable +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; Software Transactional Memory es un mecanismo que usa clojure para gestionar +; el estado persistente. Hay unas cuantas construcciones en clojure que +; hacen uso de este mecanismo. + +; Un atom es el más sencillo. Se le da un valor inicial +(def my-atom (atom {})) + +; Actualiza un atom con swap! +; swap! toma una función y la llama con el valor actual del atom +; como su primer argumento, y cualquier argumento restante como el segundo +(swap! my-atom assoc :a 1) ; Establece my-atom al resultado de (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Establece my-atom al resultado de (assoc {:a 1} :b 2) + +; Usa '@' para no referenciar al atom sino para obtener su valor +my-atom ;=> Atom<#...> (Regresa el objeto Atom) +@my-atom ; => {:a 1 :b 2} + +; Un sencillo contador usando un atom sería +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; Otros forms que utilizan STM son refs y agents. +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +### Lectura adicional + +Ésto queda lejos de ser exhaustivo, pero espero que sea suficiente para que puedas empezar tu camino. + +Clojure.org tiene muchos artículos: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org contiene documentación con ejemplos para la mayoría de +funciones principales (pertenecientes al core): +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure es una genial forma de mejorar tus habilidades con clojure/FP: +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que iniciarse en Clojure: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown new file mode 100644 index 00000000..6bf430e6 --- /dev/null +++ b/es-es/coffeescript-es.html.markdown @@ -0,0 +1,57 @@ +--- +language: coffeescript +lang: es-es +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +translators: + - ["Pablo Elices", "http://github.com/pabloelices"] +filename: coffeescript-es.coffee +--- + +``` coffeescript +# CoffeeScript es un lenguaje hipster. +# Tiene convenciones de muchos lenguajes modernos. +# Los comentarios son como en Ruby y Python, usan almohadillas. + +### +Los comentarios en bloque son como estos, y se traducen directamente a '/*' y '*/' +para el código JavaScript resultante. + +Deberías entender la mayor parte de la semántica de JavaScript antes de continuar. +### + +# Asignación: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# Condiciones: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# Funciones: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +# Rangos: +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# Objetos: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Número de argumentos variable: +race = (winner, runners...) -> + print winner, runners + +# Existencia: +alert "I knew it!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# Listas: +cubes = (math.cube num for num in list) #=> ... +``` diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown new file mode 100644 index 00000000..ef26d8ce --- /dev/null +++ b/es-es/csharp-es.html.markdown @@ -0,0 +1,632 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] +translators: + - ["Olfran Jiménez", "https://twitter.com/neslux"] +filename: LearnCSharp-es.cs +lang: es-es +--- + +C# es un lenguaje orientado a objetos elegante y de tipado seguro que +permite a los desarrolladores construir una variedad de aplicaciones +seguras y robustas que se ejecutan en el Framework .NET. + +[Lee más aquí.](http://msdn.microsoft.com/es-es/library/vstudio/z1zx9t92.aspx) + +```c# +// Los comentarios de una sola línea comienzan con // +/* +Los comentarios de múltiples líneas son de esta manera +*/ +/// <summary> +/// Este es un comentario de documentación XML +/// </summary> + +// Especifica el espacio de nombres que estará usando la aplicación +using System; +using System.Collections.Generic; + + +// Define un ambito para organizar el código en "paquetes" +namespace Learning +{ + // Cada archivo .cs debe contener al menos una clase con el mismo nombre que el archivo + // Se permite colocar cualquier nombre, pero no deberías por cuestiones de consistencia. + public class LearnCSharp + { + // Una aplicación de consola debe tener un método main como punto de entrada + public static void Main(string[] args) + { + // Usa Console.WriteLine para imprimir líneas + Console.WriteLine("Hello World"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Para imprimir sin una nueva línea, usa Console.Write + Console.Write("Hello "); + Console.Write("World"); + + + /////////////////////////////////////////////////// + // Variables y Tipos + // + // Declara una variable usando <tipo> <nombre> + /////////////////////////////////////////////////// + + // Sbyte - Entero de 8 bits con signo + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Entero de 8 bits sin signo + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - Entero de 16 bits con signo + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Ushort - Entero de 16 bits sin signo + // (0 <= ushort <= 65,535) + ushort fooUshort = 10000; + + // Integer - Entero de 32 bits con signo + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Uinteger - Entero de 32 bits sin signo + // (0 <= uint <= 4,294,967,295) + uint fooUint = 1; + + // Long - Entero de 64 bits con signo + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L es usado para indicar que esta variable es de tipo long o ulong + // un valor sin este sufijo es tratado como int o uint dependiendo del tamaño. + + // Ulong - Entero de 64 bits sin signo + // (0 <= ulong <= 18,446,744,073,709,551,615) + ulong fooUlong = 100000L; + + // Float - Precisión simple de 32 bits. IEEE 754 Coma flotante + // Precisión: 7 dígitos + float fooFloat = 234.5f; + // f es usado para indicar que el valor de esta variable es de tipo float + // de otra manera sería tratado como si fuera de tipo double. + + // Double - Doble precisión de 32 bits. IEEE 754 Coma flotante + // Precisión: 15-16 dígitos + double fooDouble = 123.4; + + // Bool - true & false (verdadero y falso) + bool fooBoolean = true; + bool barBoolean = false; + + // Char - Un solo caracter Unicode de 16 bits + char fooChar = 'A'; + + // Strings + string fooString = "My string is here!"; + Console.WriteLine(fooString); + + // Formato de cadenas + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + Console.WriteLine(fooFormattedString); + + // Formato de fechas + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // \n es un caracter de escape que comienza una nueva línea + string barString = "Printing on a new line?\nNo Problem!"; + Console.WriteLine(barString); + + // Puede ser escrito mejor usando el símbolo @ + string bazString = @"Here's some stuff + on a new line!"; + Console.WriteLine(bazString); + + // Las comillas deben ser escapadas + // usa \" para escaparlas + string quotedString = "some \"quoted\" stuff"; + Console.WriteLine(quotedString); + + // usa "" cuando las cadenas comiencen con @ + string quotedString2 = @"some MORE ""quoted"" stuff"; + Console.WriteLine(quotedString2); + + // Usa const o readonly para hacer las variables inmutables + // los valores const son calculados en tiempo de compilación + const int HOURS_I_WORK_PER_WEEK = 9001; + + // Tipos que aceptan valores NULL (Nullable) + // cualquier tipo de dato puede ser un tipo nulo añadiendole el sufijo ? + // <tipo>? <variable> = <valor> + int? nullable = null; + Console.WriteLine("Nullable variable: " + nullable); + + // Para usar valores nulos, tienes que usar la propiedad Value + // o usar conversión explícita + string? nullableString = "not null"; + Console.WriteLine("Nullable value is: " + nullableString.Value + " or: " + (string) nullableString ); + + // ?? is una manera corta de especificar valores por defecto + // en caso de que la variable sea null + int notNullable = nullable ?? 0; + Console.WriteLine("Not nullable variable: " + notNullable); + + // var - el compilador escogerá el tipo de dato más apropiado basado en el valor + var fooImplicit = true; + + /////////////////////////////////////////////////// + // Estructura de datos + /////////////////////////////////////////////////// + Console.WriteLine("\n->Data Structures"); + + // Arreglos + // El tamaño del arreglo debe decidirse al momento de la declaración + // El formato para declarar un arreglo es el siguiente: + // <tipo_de_dato>[] <nombre_variable> = new <tipo_de_dato>[<tamaño>]; + int[] intArray = new int[10]; + string[] stringArray = new string[1]; + bool[] boolArray = new bool[100]; + + // Otra forma de declarar e inicializar un arreglo + int[] y = { 9000, 1000, 1337 }; + + // Indexar arreglos - Acceder a un elemento + Console.WriteLine("intArray @ 0: " + intArray[0]); + + // Los arreglos son de índice cero y son mutables. + intArray[1] = 1; + Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1 + + // Listas + // Las listas son usadas más frecuentemente que los arreglos ya que son más flexibles + // El formato para declarar una lista es el siguiente: + // List<tipo_de_dato> <nombre_variable> = new List<tipo_de_dato>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + + // Otra forma de declarar e inicializar una lista + List<int> z = new List<int> { 9000, 1000, 1337 }; + + // Indexar una lista - Acceder a un elemento + // Las listas son de índice cero y son mutables. + Console.WriteLine("z @ 0: " + z[2]); + + // Las listas no tienen valores por defecto; + // Un valor debe ser añadido antes de acceder al índice + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + + // Otras estructuras de datos a chequear: + // + // Pilas/Colas + // Diccionarios + // Colecciones de sólo lectura + // Tuplas (.Net 4+) + + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // Modo corto para múltiples declaraciones + + // La aritmética es sencilla + Console.WriteLine("1+2 = " + (i1 + i2)); // => 3 + Console.WriteLine("2-1 = " + (i2 - i1)); // => 1 + Console.WriteLine("2*1 = " + (i2 * i1)); // => 2 + Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down) + + // Módulo + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Operadores de comparación + Console.WriteLine("3 == 2? " + (3 == 2)); // => false + Console.WriteLine("3 != 2? " + (3 != 2)); // => true + Console.WriteLine("3 > 2? " + (3 > 2)); // => true + Console.WriteLine("3 < 2? " + (3 < 2)); // => false + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true + + // Operadores a nivel de bits + /* + ~ Complemento a nivel de bits + << Desplazamiento a la izquierda con signo + >> Desplazamiento a la derecha con signo + >>> Desplazamiento a la derecha sin signo + & AND a nivel de bits + ^ XOR a nivel de bits + | OR a nivel de bits + */ + + // Incremento + int i = 0; + Console.WriteLine("\n->Inc/Dec-remento"); + Console.WriteLine(i++); //i = 1. Posincrementación + Console.WriteLine(++i); //i = 2. Preincremento + Console.WriteLine(i--); //i = 1. Posdecremento + Console.WriteLine(--i); //i = 0. Predecremento + + + /////////////////////////////////////// + // Estructuras de control + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // Las condiciones if son como en lenguaje c + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // Operador ternario + // Un simple if/else puede ser escrito de la siguiente manera; + // <condición> ? <true> : <false> + string isTrue = (true) ? "True" : "False"; + Console.WriteLine("Ternary demo: " + isTrue); + + + // Bucle while + int fooWhile = 0; + while (fooWhile < 100) + { + //Console.WriteLine(fooWhile); + //Incrementar el contador + //Iterar 99 veces, fooWhile 0->99 + fooWhile++; + } + Console.WriteLine("fooWhile Value: " + fooWhile); + + // Bucle Do While + int fooDoWhile = 0; + do + { + //Console.WriteLine(fooDoWhile); + //Incrementar el contador + //Iterar 99 veces, fooDoWhile 0->99 + fooDoWhile++; + } while (fooDoWhile < 100); + Console.WriteLine("fooDoWhile Value: " + fooDoWhile); + + // Bucle For + int fooFor; + //Estructura del bucle for => for(<declaración_inicial>; <condición>; <incremento>) + for (fooFor = 0; fooFor < 10; fooFor++) + { + //Console.WriteLine(fooFor); + //Iterated 10 times, fooFor 0->9 + } + Console.WriteLine("fooFor Value: " + fooFor); + + // Switch Case + // El switch funciona con los tipos de datos byte, short, char e int + // También funciona con las enumeraciones (discutidos en in Tipos Enum), + // la clase string y algunas clases especiales que encapsulan + // tipos primitivos: Character, Byte, Short, Integer. + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + default: + monthString = "Some other month"; + break; + } + Console.WriteLine("Switch Case Result: " + monthString); + + + //////////////////////////////// + // Conversión de tipos de datos + //////////////////////////////// + + // Convertir datos + + // Convertir String a Integer + // esto generará una excepción al fallar la conversión + int.Parse("123");//retorna una versión entera de "123" + + // TryParse establece la variable a un tipo por defecto + // en este caso: 0 + int tryInt; + int.TryParse("123", out tryInt); + + // Convertir Integer a String + // La clase Convert tiene algunos métodos para facilitar las conversiones + Convert.ToString(123); + + /////////////////////////////////////// + // Clases y Funciones + /////////////////////////////////////// + + Console.WriteLine("\n->Classes & Functions"); + + // (Definición de la clase Bicycle (Bicicleta)) + + // Usar new para instanciar una clase + Bicycle trek = new Bicycle(); + + // Llamar a los métodos del objeto + trek.speedUp(3); // Siempre deberías usar métodos setter y métodos getter + trek.setCadence(100); + + // ToString es una convención para mostrar el valor del objeto. + Console.WriteLine("trek info: " + trek.ToString()); + + // Instanciar otra nueva bicicleta + Bicycle octo = new Bicycle(5, 10); + Console.WriteLine("octo info: " + octo.ToString()); + + // Instanciar un Penny Farthing (Biciclo) + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.ToString()); + + Console.Read(); + } // Fin del método main + + + } // Fin de la clase LearnCSharp + + // Puedes incluir otras clases en un archivo .cs + + + // Sintaxis para la declaración de clases: + // <public/private/protected> class <nombre_de_clase>{ + // //campos, constructores, funciones todo adentro de la clase. + // //las funciones son llamadas métodos como en java. + // } + + public class Bicycle + { + // Campos/Variables de la clase Bicycle + public int cadence; // Public: Accesible desde cualquier lado + private int _speed; // Private: Sólo es accesible desde dentro de la clase + protected int gear; // Protected: Accesible desde clases y subclases + internal int wheels; // Internal: Accesible en el ensamblado + string name; // Todo es privado por defecto: Sólo es accesible desde dentro de esta clase + + // Enum es un tipo valor que consiste un una serie de constantes con nombres + public enum Brand + { + AIST, + BMC, + Electra, + Gitane + } + // Definimos este tipo dentro de la clase Bicycle, por lo tanto es un tipo anidado + // El código afuera de esta clase debería referenciar este tipo como Bicycle.Brand + + public Brand brand; // Declaramos un tipo enum, podemos declarar un campo de este tipo + + // Los miembros estáticos pertenecen al tipo mismo, no a un objeto en específico. + static public int bicyclesCreated = 0; + // Puedes acceder a ellos sin referenciar ningún objeto: + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + + // Los valores readonly (Sólo lectura) son establecidos en tiempo de ejecución + // sólo pueden ser asignados al momento de la declaración o dentro de un constructor + readonly bool hasCardsInSpokes = false; // privado de sólo lectura + + // Los constructores son una forma de crear clases + // Este es un constructor por defecto + private Bicycle() + { + gear = 1; + cadence = 50; + _speed = 5; + name = "Bontrager"; + brand = Brand.AIST; + bicyclesCreated++; + } + + // Este es un constructor específico (contiene argumentos) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, Brand brand) + { + this.gear = startGear; // La palabra reservada "this" señala el objeto actual + this.cadence = startCadence; + this._speed = startSpeed; + this.name = name; // Puede ser útil cuando hay un conflicto de nombres + this.hasCardsInSpokes = hasCardsInSpokes; + this.brand = brand; + } + + // Los constructores pueden ser encadenados + public Bicycle(int startCadence, int startSpeed, Brand brand) : + this(startCadence, startSpeed, 0, "big wheels", true) + { + } + + // Sintaxis para Funciones: + // <public/private/protected> <tipo_retorno> <nombre_funcion>(<args>) + + // Las clases pueden implementar getters y setters para sus campos + // o pueden implementar propiedades + + // Sintaxis para la declaración de métodos: + // <ámbito> <tipo_retorno> <nombre_método>(<argumentos>) + public int GetCadence() + { + return cadence; + } + + // Los métodos void no requieren usar return + public void SetCadence(int newValue) + { + cadence = newValue; + } + + // La palabra reservada virtual indica que este método puede ser sobrescrito + public virtual void SetGear(int newValue) + { + gear = newValue; + } + + // Los parámetros de un método pueden tener valores por defecto. + // En este caso, los métodos pueden ser llamados omitiendo esos parámetros + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // Propiedades y valores get/set + // Cuando los datos sólo necesitan ser accedidos, considera usar propiedades. + // Las propiedades pueden tener get, set o ambos + private bool _hasTassles; // variable privada + public bool HasTassles // acceso público + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // Las propiedades pueden ser auto implementadas + public int FrameSize + { + get; + // Puedes especificar modificadores de acceso tanto para get como para set + // esto significa que sólo dentro de la clase Bicycle se puede modificar Framesize + private set; + } + + //Método para mostrar los valores de atributos de este objeto. + public override string ToString() + { + return "gear: " + gear + + " cadence: " + cadence + + " speed: " + _speed + + " name: " + name + + " cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Los métodos también pueden ser estáticos. Puede ser útil para métodos de ayuda + public static bool DidWeCreateEnoughBycles() + { + // Dentro de un método esático, + // Sólo podemos hacer referencia a miembros estáticos de clases + return bicyclesCreated > 9000; + } // Si tu clase sólo necesita miembros estáticos, + // considera establecer la clase como static. + + } // fin de la clase Bicycle + + // PennyFarthing es una subclase de Bicycle + class PennyFarthing : Bicycle + { + // (Penny Farthings son las bicicletas con una rueda delantera enorme. + // No tienen engranajes.) + + // llamar al constructor de la clase padre + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true) + { + } + + public override void SetGear(int gear) + { + gear = 0; + } + + public override string ToString() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Llamar a la versión base del método + return reuslt; + } + } + + // Las interfaces sólo contienen las declaraciones + // de los miembros, sin la implementación. + interface IJumpable + { + void Jump(int meters); // todos los miembros de interfaces son implícitamente públicos + } + + interface IBreakable + { + // Las interfaces pueden contener tanto propiedades como métodos, campos y eventos + bool Broken { get; } + } + + // Las clases sólo heredan de alguna otra clase, pero pueden implementar + // cualquier cantidad de interfaces + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public void Broken + { + get + { + return damage > 100; + } + } + } +} // Fin del espacio de nombres + +``` + +## Temas no cubiertos + + * Flags + * Attributes + * Generics (T), Delegates, Func, Actions, lambda expressions + * Static properties + * Exceptions, Abstraction + * LINQ + * ASP.NET (Web Forms/MVC/WebMatrix) + * Winforms + * Windows Presentation Foundation (WPF) + + + +## Lecturas recomendadas + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/es-es/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + + + +[Convenciones de código de C#](http://msdn.microsoft.com/es-es/library/vstudio/ff926074.aspx) diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown new file mode 100644 index 00000000..31000785 --- /dev/null +++ b/es-es/css-es.html.markdown @@ -0,0 +1,244 @@ +--- +language: css +filename: learncss-es.css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Daniel Zendejas","https://github.com/DanielZendejas"] +lang: es-es +--- + +Tutorial de CSS en español + +En los primeros días de la web no había elementos visuales, todo +era texto plano. Pero después, con el desarrollo de los navegadores, +las páginas con contenido visual empezaron a ser más comunes. +CSS es el lenguaje estándar que existe para separar el contenido +(HTML) y el aspecto visual de las páginas web. + +Lo que CSS hace es proveer con una sintaxis que te permite apuntar a distintos +elementos HTML y asignarles diferentes propiedades visuales. + +CSS, como cualquier otro lenguaje, tiene múltiples versiones. Aquí nos enfocamos +en CSS 2.0. No es la versión más reciente pero sí la más soportada y compatible. + +**NOTA:** Como los resultados de CSS son efectos visuales, para aprenderlo, +necesitarás probar todo tipo de cosas en ambientes como +[dabblet](http://dabblet.com/). Este artículo se enfoca, principalmente, en +la sintaxis y consejos generales. + +```css +/* ¡Los comentarios aparecen dentro de diagonal-asterisco, justo como esta línea! */ + +/* #################### + ## SELECTORES + ####################*/ + +/* Generalmente, la sentencia principal en CSS es muy simple. */ +selector { propiedad: valor; /* más propiedades separados por punto y coma...*/ } + +/* El selector es usado para apuntar a (seleccionar) un elemento en la página. + +¡Puedes apuntar a todos los elementos en la página con el asterisco! */ +* { color:red; } + +/* +Dado un elemento como este en la página: + +<div class='una-clase clase2' id='unaId' attr='valor' /> +*/ + +/* puedes seleccionar el <div> por el nombre de su clase */ +.una-clase { } + +/*¡O por sus dos clases! */ +.una-clase.clase2 { } + +/* O por el nombre de su elemento */ +div { } + +/* O por su Id */ +#unaId { } + +/* ¡O por el hecho de que tiene un atributo! */ +[attr] { font-size:smaller; } + +/* O por el hecho de que el atributo tiene un valor determinado */ +[attr='valor'] { font-size:smaller; } + +/* Empieza con un valor ('val' en este caso)*/ +[attr^='val'] { font-size:smaller; } + +/* O termina con un valor ('or' en este caso) */ +[attr$='or'] { font-size:smaller; } + +/* O incluso contiene un valor ('lo' en este caso) */ +[attr~='lo'] { font-size:smaller; } + +/*Más importante, puedes combinar estos criterios de búsqueda entre sí. +No debe existir ningún espacio entre estas partes porque hace que el +significado cambie.*/ +div.una-clase[attr$='or'] { } + +/* También puedes seleccionar un elemento HTML basándote en sus padres*/ + +/* Un elemento que es hijo directo de otro elemento (Seleccionado de la forma que +vimos anteriormente) */ + +div.un-padre > .nombre-clase {} + +/* O cualquiera de sus ancestros en la jerarquía*/ +/* La siguiente sentencia selecciona a cualquier elemento que tenga una clase +"nombre-clase" y sea hijo de un div con clase "un-padre" EN CUALQUIER PROFUNDIDAD*/ +div.un-padre .nombre-clase {} + +/* advertencia: el mismo selector sin espacio tiene otro significado. ¿Puedes +identificar la diferencia?*/ + +/* También puedes seleccionar un elemento basado en su hermano inmediato previo*/ +.yo-estoy-antes + .este-elemento { } + +/*o cualquier hermano previo */ +.yo-soy-cualquiera-antes ~ .estes-elemento {} + +/* Existen algunas pseudo-clases que permiten seleccionar un elemento +basado en el comportamiendo de la página (a diferencia de la estructura de +la página) */ + +/* Por ejemplo, para cuando pasas el mouse por encima de un elemento */ +:hover {} + +/* o una liga visitada*/ +:visited {} + +/* o una liga no visitada aún*/ +:link {} + +/* o un elemento de un formulario que esté seleccionado */ +:focus {} + + +/* #################### + ## PROPIEDADES + ####################*/ + +selector { + + /* Unidades */ + width: 50%; /* en porcentaje */ + font-size: 2em; /* dos veces el tamaño de la fuente actual */ + width: 200px; /* en pixeles */ + font-size: 20pt; /* en puntos */ + width: 5cm; /* en centimetros */ + width: 50mm; /* en milimetros */ + width: 5in; /* en pulgadas */ + + /* Colores */ + background-color: #F6E; /* en hexadecimal corto */ + background-color: #F262E2; /* en hexadecimal largo */ + background-color: tomato; /* puede ser un color con nombre */ + background-color: rgb(255, 255, 255); /* en rgb */ + background-color: rgb(10%, 20%, 50%); /* en rgb percent */ + background-color: rgba(255, 0, 0, 0.3); /* en rgb semi-transparente (con valor alfa)*/ + + /* Imagenes */ + background-image: url(/ruta-a-la-imagen/imagen.jpg); + + /* Fuentes */ + font-family: Arial; + font-family: "Courier New"; /* si el nombre contiene espacios, debe ir entre comillas */ + font-family: "Courier New", Trebuchet, Arial; /* si la primera fuente no se encontró + entonces se busca la seguna, o la tercera, así recursivamente*/ +} + +``` + +## Uso + +Guarda cualquier CSS que quieras en un archivo con extensión `.css`. + +```xml +<!-- Necesitas incluir tu archivo CSS en el elemento <head> de tu HTML: --> +<link rel='stylesheet' type='text/css' href='ruta/archivoDeEstilos.css' /> + +<!-- +también puedes incluir CSS dentro del archivo HTML. Esta no es una buena práctica +y debe ser evitada. +--> +<style> + selector { propiedad:valor; } +</style> + +<!-- +También se pueden aplicar propiedades al elemento directamente. +Esta práctica también debe ser evitada a toda costa +--> +<div style='propiedad:valor;'> +</div> + +``` + +## Preferencia y orden + +Como te habrás dado cuenta un elemento puede ser seleccionado por más +de un selector. En este caso alguna de las reglas cobra preferencia +sobre las otras: + +Dado el siguiente CSS: + +```css +/*A*/ +p.clase1[attr='valor'] + +/*B*/ +p.clase1 {} + +/*C*/ +p.clase2 {} + +/*D*/ +p {} + +/*E*/ +p { propiedad: valor !important; } + +``` + +Y el siguiente HTML: + +```xml +<p style='/*F*/ propiedad:valor;' class='clase1 clase2' attr='valor'> +</p> +``` + +El orden respetado es el siguiente: +Recuerda, la preferencia es por cada **property**, no para el bloque completo. + +* `E` tiene la preferencia más elevada gracias a la palabra `!important`. + Es recomendado evitar esto a menos que sea estrictamente necesario incluirlo. +* `F` le sigue, porque es estilo incrustado directamente en el HTML. +* `A` le sigue, porque es más específico que cualquier otra opción. + más específico = más especificadores. Aquí hay tres especificadores: elemento `p` + + nombre de la clase `clase1` + un atributo `attr='valor'` +* `C` le sigue. Aunque tiene el mismo número de especificadores como `B` + pero aparece después. +* Luego va `B` +* y al final `D`. + +## Compatibilidad + +La mayoría de las funcionalidades de CSS2 (y gradualmente de CSS3) son compatibles +en todos los navegadores y dispositivos. Pero siempre es vital tener en mente la +compatibilidad y disponibilidad del CSS que uses con respecto a los navegadores +y dispositivos para los que desarrolles. + + +[QuirksMode CSS](http://www.quirksmode.org/css/) es una excelente referencia para esto. + +## Referencias + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) + diff --git a/es-es/elisp-es.html.markdown b/es-es/elisp-es.html.markdown new file mode 100644 index 00000000..a6cd3934 --- /dev/null +++ b/es-es/elisp-es.html.markdown @@ -0,0 +1,378 @@ +--- +language: elisp +contributors: + - ["Bastien Guerry", "http://bzg.fr"] +translators: + - ["Guillermo Vayá", "http://willyfrog.es"] +lang: es-es +filename: learn-emacs-lisp-es.el +--- + +```scheme +;; Introduccion a Emacs Lisp en 15 minutos (v0.2d) +;; +;; Autor: Bastien / @bzg2 / http://bzg.fr +;; Traducción: Guillermo Vayá / @Driadan / http://willyfrog.es +;; +;; Antes de nada, lee este texto de Peter Norvig: +;; Traducido: http://loro.sourceforge.net/notes/21-dias.html +;; Original: http://norvig.com/21-days.html +;; +;; Ahora instala GNU Emacs 24.3: +;; +;; Debian: apt-get install emacs +;; (o sigue las instrucciones de tu distribución preferida) +;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg +;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip +;; +;; Puedes encontrar información general sobre Emacs en: +;; http://www.gnu.org/software/emacs/#Obtaining + +;; Aviso importante: +;; +;; Seguir este tutorial no provocará daños en tu ordenador a menos que +;; te enfades tanto que que acabes tirándolo al suelo. En tal caso +;; declino cualquier responsabilidad. ¡A divertirse! + + +;; "N. del. T.": Algunos términos comunes de la informática se han dejado +;; sin traducir ya que es mucho más probable que el lector los conozca en +;; su forma en inglés, siendo la versión en español de muy raro uso. +;; Además "sexps" se ha decidido traducir por sexpresión. +;; Por último, añadir que no se han traducido los ejemplos de código ya que no +;; es necesario entender qué dice el string para comprender el funcionamiento +;; y podría llevar a error. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Inicia Emacs. +;; +;; Pulsa la tecla `q' para pasar el mensaje de bienvenida. +;; +;; Mira a la línea gris en la parte inferior de la ventana: +;; +;; "*scratch*" es el nombre del espacio editable donde estás. +;; A este espacio editable se le llama "buffer". +;; +;; Scratch es el buffer por defecto cuando abres Emacs. +;; En Emacs nunca editas ficheros, sino que editas buffers que +;; posteriormente pueden grabarse a un fichero. +;; can save to a file. +;; +;; "Lisp interaction" indica el conjunto de ordenes disponibles. +;; +;; Emacs dispone de un set de comandos disponibles en cualquier buffer +;; ("built-ins") y aparte varios conjuntos de ordenes disponibles +;; según el modo específico que esté activo. En nuestro caso +;; estamos usando `lisp-interaction-mode', el cual incluye las +;; ordenes necesarias para evaluar y navegar código Elisp. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Un punto y coma comienza un comentario. Pueden ponerse en cualquier +;; posicion de la linea. +;; +;; Los programas en Elisp se componen de expresiones simbólicas +;; tambien llamadas "sexps": +(+ 2 2) + +;; Esta expresión simbólica se lee tal que "Suma 2 y 2" + +;; Las sexpresiones se rodean por paréntesis, y pueden anidarse: +(+ 2 (+ 1 1)) + +;; Una expresion simbólica está formada bien por átomos o bien por otras +;; expresiones simbólicas. En el ejemplo de arriba, 1 y 2 son átomos, +;; mientras que (+ 2 (+ 1 1)) y (+ 1 1) son expresiones simbólicas. + +;; Gracias a `lisp-interaction-mode' puedes evaluar las sexpresiones. +;; Coloca el cursor justo despues del paréntesis de cierre y +;; mantén pulsada la tecla Control y la j (para abreviar usaremos "C-j"). + +(+ 3 (+ 1 2)) +;; ^ pon aquí el cursor +;; `C-j' => 6 + +;; `C-j' añade el resultado de la evaluación al buffer. + +;; `C-xC-e' muestra el mismo resultado pero en la linea inferior +;; la cual se llama "minibuffer". Este será el metodo que usaremos +;; normalmente para no llenar el buffer con texto inútil. + +;; `setq' guarda un valor en una variable: +(setq my-name "Bastien") +;; `C-xC-e' => "Bastien" (aparece en el mini-buffer) + +;; `insert' añade "Hello!" en el punto donde esté tu cursor: +(insert "Hello!") +;; `C-xC-e' => "Hello!" + +;; Aunque hemos usado `insert' con solo un parámetro "Hello!", se +;; pueden pasar más. Por ejemplo, en esta otra sexpresión usamos dos: + +(insert "Hello" " world!") +;; `C-xC-e' => "Hello world!" + +;; Se pueden usar variables en lugar de strings: +(insert "Hello, I am " my-name) +;; `C-xC-e' => "Hello, I am Bastien" + +;; Puedes combinar sexpresiones en funciones: +(defun hello () (insert "Hello, I am " my-name)) +;; `C-xC-e' => hello + +;; Evaluemos la funcion: +(hello) +;; `C-xC-e' => Hello, I am Bastien + +;; Los parentesis vacios en la definicion de una funcion indican +;; que no acepta parámetros. En cualquier caso, usar `my-name' siempre +;; es aburrido, asi que vamos a hacer que la función accepte un parámetro +;; (en este caso el parametro se llama "name"): +(defun hello (name) (insert "Hello " name)) +;; `C-xC-e' => hello + +;; Ahora vamos a llamar a la funcion con el string "you" como valor para +;; el único parámetro que posee. +(hello "you") +;; `C-xC-e' => "Hello you" + +;; ¡Genial! + +;; Descansa un poco y respira. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Ahora cambiaremos al nuevo buffer, llamado "*test*", en una nueva ventana. + +(switch-to-buffer-other-window "*test*") +;; `C-xC-e' +;; => [La pantalla ahora tiene dos ventanas y el cursor está en el buffer *test*] + +;; Mueve el ratón sobre la ventana superior y pulsa el boton izdo. para volver. +;; Otra forma es usando `C-xo' (pulsa simultaneamente control y x y luego la o) +;; para ir a la otra ventana. + +;; Se pueden combinar varias sexpresiones mediante `progn': +(progn + (switch-to-buffer-other-window "*test*") + (hello "you")) +;; `C-xC-e' +;; => [De las dos ventanas de la pantalla, el cursor está en la marcada como *test*] + +;; A partir de ahora, si no te importa, dejaremos de decir que pulses `C-xC-e': +;; tendrás que hacerlo para ejecutar cada sexpresión que siga. + +;; También tendrás que volver al buffer *scratch* bien con el ratón o con `C-xo'. + +;; En ocasiones será util limpiar el buffer: +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "there")) + +;; O volver a la ventana anterior: +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "you") + (other-window 1)) + +;; Puedes enlazar un valor a una variable local con `let': +(let ((local-name "you")) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello local-name) + (other-window 1)) + +;; En este caso, no hace falta añadir `progn' ya que `let' permite combinar +;; varias sexpresiones. + +;; Vamos a darle formato a un string: +(format "Hello %s!\n" "visitor") + +;; Cada %s indica la posicion donde irá un string, el cual será reemplazado +;; por "visitor". "\n" es el caracter de nueva línea. + +;; Mejoremos nuestra funcion usando `format': +(defun hello (name) + (insert (format "Hello %s!\n" name))) + +(hello "you") + +;; Creemos una nueva funcion que utililce `let': +(defun greeting (name) + (let ((your-name "Bastien")) + (insert (format "Hello %s!\n\nI am %s." + name ; the argument of the function + your-name ; the let-bound variable "Bastien" + )))) + +;; Y ahora la evaluamos: +(greeting "you") + +;; Algunas funciones son interactivas: +(read-from-minibuffer "Enter your name: ") + +;; Al evaluar esta función, ésta devuelve lo que hayas introducido. + +;; Ahora hagamos nuestra función `greeting' preguntar por tu nombre: +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (insert (format "Hello!\n\nI am %s and you are %s." + from-name ; the argument of the function + your-name ; the let-bound var, entered at prompt + )))) + +(greeting "Bastien") + +;; Y ahora la completamos mostrando el resultado en la otra ventana: +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (insert (format "Hello %s!\n\nI am %s." your-name from-name)) + (other-window 1))) + +;; Probémosla: +(greeting "Bastien") + +;; Descansa un poco y respira. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Creemos una lista de nombres: +(setq list-of-names '("Sarah" "Chloe" "Mathilde")) + +;; Para coger el primer elemento de la lista usaremos `car': +(car list-of-names) + +;; Para coger todos menos el primer elemento de la lista +;; usaremos `cdr': +(cdr list-of-names) + +;; Para añadir un elemento al comienzo de la lista utilizamos `push': +(push "Stephanie" list-of-names) + +;; OJO: `car' y `cdr' no modifican la lista, mientras que `push' sí. +;; ¡Es una diferencia importante! Algunas funciones no tienen efectos +;; colaterales (como `car') mientras que otras sí (como `push'). +;; "N. del T.": estos efectos colaterales se les llama `side-effects' en +;; las distintas variantes de lisp. + +;; Llamemos a `hello' con cada elemento de `list-of-names': +(mapcar 'hello list-of-names) + +;; Retocamos `greeting' para que salude a todos los que estén en `list-of-names': +(defun greeting () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (mapcar 'hello list-of-names) + (other-window 1)) + +(greeting) + +;; ¿Te acuerdas de la función `hello' definida un poco más arriba? +;; Recibía un parámetro: `name'. Así que `mapcar' llama a `hello' con cada +;; elemento de `list-of-names' como parámetro de `hello'. + +;; Ahora ordenaremos un poco lo que tenemos en el buffer: + +(defun replace-hello-by-bonjour () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (search-forward "Hello") + (replace-match "Bonjour")) + (other-window 1)) + +;; (goto-char (point-min)) mueve el cursor al principio del buffer. +;; (search-forward "Hello") busca un string "Hello". +;; (while x y) evalua la/s sexpresion/es y mientras que x devuelva +;; alguna cosa. +;; En el momento que x devuelva `nil' (es decir nada), sale del +;; bucle `while'. + +(replace-hello-by-bonjour) + +;; Observamos que todas las veces que teníamos la palabra "Hello" en el buffer *test* +;; han sido reemplazadas por "Bonjour". + +;; Y además, hemos obtenido un error: "Search failed: Hello". +;; +;; Para evitar este error, hay que decirle a `search-forward' si debería dejar de +;; buscar en el buffer en algún momento y si debería fallar sin quejarse cuando +;; no encuentra nada. + +;; (search-forward "Hello" nil t) justo hace eso: + +;; El argumento `nil' significa que la busqueda no está ligada a ninguna posición. +;; Y el argumento `t' le pide que no diga nada si no encuentra el string. + +;; Usaremos esta sexpresión en la función siguiente, la cual ya +;; no muestra ningún error: + +(defun hello-to-bonjour () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + ;; Say hello to names in `list-of-names' + (mapcar 'hello list-of-names) + (goto-char (point-min)) + ;; Replace "Hello" by "Bonjour" + (while (search-forward "Hello" nil t) + (replace-match "Bonjour")) + (other-window 1)) + +(hello-to-bonjour) + +;; Añadamos algo de color a los nombres: + +(defun boldify-names () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (re-search-forward "Bonjour \\(.+\\)!" nil t) + (add-text-properties (match-beginning 1) + (match-end 1) + (list 'face 'bold))) + (other-window 1)) + +;; Esta función nos presenta `re-search-forward': en vez de +;; buscar el string "Bonjour" exacto, se busca por un patrón +;; usando una "expresión regular" (lo cual se muestra abreviado +;; en el prefijo "re-" del inglés "Regular Expression"). + +;; La expresión regular a utilizar es "Bonjour \\(.+\\)!" y se traduce como: +;; el string "Bonjour ", seguido de +;; un grupo de | representado por \\( ... \\) +;; cualquier caracter | representado por . +;; al menos una vez | representado por + +;; y el string "!". + +;; ¿Preparado? ¡Probemoslo! + +(boldify-names) + +;; `add-text-properties' añade propiedades al texto, como una fuente. + +;; ¡Hale! ¡Ya lo tenemos! ¡Feliz hacking! + +;; Si quieres saber más sobre una función o una variable: +;; +;; C-h v la-variable RET +;; C-h f la-funcion RET +;; +;; Si quieres leer el manual de Emacs Lisp desde dentro de Emacs: +;; +;; C-h i m elisp RET +;; +;; Para leer una introducción en linea de Emacs Lisp: +;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html + +;; Me gustaría agradecer a las siguientes personas su feedback y sugerencias: +;; - Wes Hardaker +;; - notbob +;; - Kevin Montuori +;; - Arne Babenhauserheide +;; - Alan Schmitt +;; - LinXitoW +;; - Aaron Meurer +``` diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown new file mode 100644 index 00000000..18b544b4 --- /dev/null +++ b/es-es/git-es.html.markdown @@ -0,0 +1,409 @@ +--- +category: tool +tool: git +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translator: + - ["Raúl Ascencio", "http://rscnt.github.io"] +filename: LearnGit.txt +lang: es-es + +--- + +Git es un sistema de control de versiones distribuido diseñado para manejar +cualquier tipo de proyecto, ya sea grande o pequeño, con velocidad y eficiencia. + +Git realiza esto haciendo "snapshots" del proyecto, con ello permite +versionar y administrar nuestro código fuente. + +## Versionamiento, conceptos. + +### Qué es el control de versiones? +El control de versiones es un sistema que guarda todos los cambios realizados en +uno o varios archivos, a lo largo del tiempo. + +### Versionamiento centralizado vs Versionamiento Distribuido. + ++ El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar + archivos. ++ El versionamiento distribuido se enfoca en compartir los cambios realizados. + Cada cambio tiene un único identificador. ++ El versionamiento distribuido no tiene una estructura definida, incluso se + puede mantener el estilo de los repositorios SVN con git. + +[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones) + +### Por qué usar Git? + +* Se puede trabajar sin conexion. +* ¡Colaborar con otros es sencillo!. +* Derivar, crear ramas del proyecto (aka: Branching) es fácil. +* Combinar (aka: Merging) +* Git es rápido. +* Git es flexible. + +## Arquitectura de Git. + +### Repositorio + +Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka: +comits), y encabezados (aka: heads). Imagina que un repositorio es una clase, +y que sus atributos otorgan acceso al historial del elemento, además de otras +cosas. + +Un repositorio esta compuesto por la carpeta .git y un "árbol de trabajo". + +### Directorio .git (componentes del repositorio) + +El directorio .git contiene todas las configuraciones, registros, branches, HEAD +y mas. + +[Lista detallada.](http://es.gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### Directorio de trabajo (componentes del repositorio) + +Es basicamente los directorios y archivos dentro del repositorio. La mayoría de +las veces se le llama "directorio de trabajo". + +### Índice (componentes del directorio .git) + +El índice es el área de inicio en git. Es basicamente la capa que separa el +directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores +más poder sobre lo que se envía y se recibe del repositorio. + +### Commit (aka: cambios) + +Un commit es una captura de un conjunto de cambios, o modificaciones hechas en +el directorio de trabajo. Por ejemplo, si se añaden 5 archivos, se eliminan 2, +estos cambios se almacenarán en un commit (aka: captura). Este commit puede ser o +no ser enviado (aka: "pusheado") hacia un repositorio. + +### Branch (rama) + +Un "branch", es escencialmente un apuntador hacia el último commit (cambio +registrado) que se ha realizado. A medida que se realizan más commits, este +apuntador se actualizará automaticamente hacia el ultimo commit. + +### "HEAD" y "head" (componentes del directorio .git) + +"HEAD" es un apuntador hacia la rama (branch) que se esta utilizando. Un +repositorio solo puede tener un HEAD activo. En cambio "head", es un apuntador a +cualquier commit realizado, un repositorio puede tener cualquier número de +"heads". + +### conceptos - recursos. + +* [Git para informáticos](http://eagain.net/articles/git-for-computer-scientists/) +* [Git para diseñadores](http://hoth.entp.com/output/git_for_designers.html) + + +## Comandos. + + +### init + +Crear un repositorio de git vacio. Las configuraciones, información almacenada y +demás son almacenadas en el directorio ".git". + +```bash +$ git init +``` + +### config + +Se utiliza para configurar las opciones ya sea globalmente, o solamente en el +repositorio. + +```bash +# Imprime y guarda algunas variables de configuracion básicas. (Globalmente) +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "corre@gmail.com" +$ git config --global user.name "nombre" +``` + +[Más sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git) + +### help + +Otorga un accceso rápido a una guía extremadamente detallada de cada comando en +git. O puede ser usada simplemente como un recordatorio de estos. + +```bash +# Una vista rápida de los comandos disponibles. +$ git help + +# Chequear todos los comandos disponibles +$ git help -a + +# Obtener ayuda especifica de un comando - manual de usuario +# git help <comando> +$ git help add +$ git help commit +$ git help init +``` + +### status + +Muestra las diferencias entre el archivo índice y el commit al cual apunta el +HEAD actualmente. + + +```bash +# Mostrará el "branch", archivos sin añadir al repo, cambios y otras +# diferencias +$ git status + +# Devuelve ayuda sobre el comando status. +$ git help status +``` + +### add + +Para añadir archivos al árbol (directorio, repositorio) de trabajo. Si no se +utiliza `git add`, los nuevos archivos no se añadirán al arbol de trabajo, por +lo que no se incluirán en los commits (cambios). + +```bash +# Añade un archivo en el directorio de trabajo actual. +$ git add FooBar.java + +# Añade un archivo que se encuentra bajo un directorio. +$ git add /directorio/del/archivo/Foo.c + +# Soporte para expresiones regulares! +$ git add ./*.py +``` + +### branch + +Administra las ramas del repositorio ("branches"). Puedes ver, editar, crear y +borrar ramas ("branches"), usando este comando. + +```bash +# lista todas las ramas (remotas y locales) +$ git branch -a + +# Añadir una nueva rama ("branch"). +$ git branch branchNueva + +# Eliminar una rama. +$ git branch -d branchFoo + +# Renombrar una rama. +# git branch -m <anterior> <nuevo> +$ git branch -m youngling padawan + +# Editar la descripcion de la rama. +$ git branch master --edit-description +``` + +### checkout + +Actualiza todos los archivos en el directorio de trabajo para que sean igual que +las versiones almacenadas en el índice, o en un árbol de trabajo especificado. + +```bash +# Despachar un repositorio. - Por defecto la master branch. (la rama principal llamada 'master') +$ git checkout +# Despacha una rama especifica. +$ git checkout padawan +# Crea una nueva rama y cambia hacia ella, es igual a utilizar: "git brach jedi; git checkout jedi" +$ git checkout -b jdei +``` + +### clone + +Clona, o copia, un repositorio existente en un nuevo directorio. También añade el +seguimiento hacia las ramas existentes del repositorio que ha sido clonado, lo que +permite subir (push) los archivos hacia una rama remota. + +```bash +# Clonar la repo de jquery. +$ git clone https://github.com/jquery/jquery.git +``` + +### commit + +Almacena el contenido actual del índice en un nuevo "commit". Este +commit contiene los cambios hechos más un resumen proporcionado por el desarrollador. + +```bash +# realizar un commit y añadirle un mensaje. +$ git commit -m "jedi anakin wil be - jedis.list" +``` + +### diff + +Muestra las diferencias entre un archivo en el directorio de trabajo, el índice +y los commits. + +```bash +# Muestra la diferencia entre un directorio de trabajo y el índice. +$ git diff + +# Muestra la diferencia entre el índice y los commits más recientes. +$ git diff --cached + +# Muestra la diferencia entre el directorio de trabajo y el commit más reciente. +$ git diff HEAD +``` + +### grep + +Permite realizar una busqueda rápida en un repositorio. + +Configuraciones opcionales: + +```bash +# Gracias a Travis Jeffery por compartir lo siguiente. +# Permite mostrar numeros de lineas en la salida de grep. +$ git config --global grep.lineNumber true + +# Realiza una búsqueda mas legible, incluyendo agrupación. +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Busca por "unaVariable" en todos los archivos .java +$ git grep 'unaVariable' -- '*.java' + +# Busca por una línea que contenga "nombreArreglo" y "agregar" o "remover" +$ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \) +``` + +Más ejemplos: + +- [Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Muestra los commits (cambios) registrados en el repositorio. + +```bash +# Muestra todos los commits. +$ git log + +# Muestra un numero x de commits. +$ git log -n 10 + +# Muestra solo los commits que se han combinado en el historial. +$ git log --merges +``` + +### merge + +Combina los cambios de commits realizados externamente dentro de la rama en la +que se trabaja. + +```bash +# Combina la rama especificada en la rama actual. +$ git merge jediMaster + +# Siempre genere un solo merge commit cuando se utiliza merge. +$ git merge --no-ff jediMaster +``` + +### mv + +Renombra o mueve un archivo + +```bash +# Renombrando un archivo. +$ git mv HolaMundo.c AdiosMundo.c + +# Moviendo un archivo. +$ git mv HolaOtraVezMundo.c ./nuevo/directorio/NuevoArchivo.c + +# Sustituye un archivo. +$ git mv -f archivoA archivoB +``` + +### pull + +Trae los cambios de un repositorio y los combina en otro en una rama diferente. + +```bash +# Actualiza el repositorio local, combinando los nuevos cambios +# de las ramas remotas "origin" y "master". +# git pull <remota> <rama> +$ git pull origin master +``` + +### push + +Envía y combina los cambios de un repositorio local a un repositorio y rama remotos. + +```bash +# Envía y combina cambios de un repositorio local hacia un repositorio remoto +# llamados "origin" y "master", respectivamente. +# git push <remota> <rama> +# git push => por defecto es lo mismo que poner => git push origin master +$ git push origin master +``` + +### rebase + +Toma todos los cambios que fueron registrados en una rama, y los repite dentro +de otra rama. *No reescribe los commits que se han empujado antes a un repositorio público.* + +```bash +# Integrar ramaExperimento dentro de la rama "master" +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[Información adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar) + +### reset (precaución) + +Reinicia el HEAD actual hacia un estado especificado. Esto permite deshacer +combinaciones (merges), pulls, commits, adds y más. Es un comando útil, pero +tambien peligroso si no se sabe lo que se hace. + +```bash +# Reinicia el área principal, con el último cambio registrado. (deja los +# directorios sin cambios) +$ git reset + +# Reinicia el área principal, con el último cambio registrado, y reescribe el +# directorio de trabajo. +$ git reset --hard + +# Mueve la rama actual hacia el commit especificado (no realiza cambios a los +# directorios), todos los cambios aún existen el directorio. +$ git reset 31f2bb1 + +# Mueve la rama actual devuelta a un commit especificado, así como el +# directorio (borra todos los cambios que no fueron registrados y todos los +# cambios realizados después del commit especificado). +$ git reset --hard 31f2bb1 +``` + +### rm + +Lo contrario de git add, git rm elimina los archivos del directorio de trabajo +actual. + +```bash +# Elimina FooBar.c +$ git rm FooBar.c + +# Elimina un archivo de un directorio. +$ git rm /directorio/del/archivo/FooBar.c +``` + +## Información Adicional + +* [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1) + +* [git-scm - Video-tutoriales](http://git-scm.com/videos) + +* [git-scm - Documentacion](http://git-scm.com/book/es) + +* [Atlassian Git - Tutoriales y Flujos de trabajo](https://www.atlassian.com/git/) + +* [SalesForce Chuleta](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown new file mode 100644 index 00000000..c41d693d --- /dev/null +++ b/es-es/go-es.html.markdown @@ -0,0 +1,450 @@ +--- +name: Go +category: language +language: Go +lang: es-es +filename: learngo-es.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] +translators: + - ["Adrian Espinosa", "http://www.adrianespinosa.com"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Nacho Pacheco -- Feb/2015", "https://github.com/gitnacho"] +--- + +Go fue creado por la necesidad de hacer el trabajo rápidamente. No es la +última tendencia en informática, pero es la forma nueva y más rápida de +resolver problemas reales. + +Tiene conceptos familiares de lenguajes imperativos con tipado estático. +Es rápido compilando y rápido al ejecutar, añade una concurrencia fácil de +entender para las CPUs de varios núcleos de hoy día, y tiene +características que ayudan con la programación a gran escala. + +Go viene con una biblioteca estándar muy buena y una entusiasta comunidad. + +```go +// Comentario de una sola línea +/* Comentario + multilínea */ + +// La cláusula `package` aparece al comienzo de cada fichero fuente. +// `main` es un nombre especial que declara un ejecutable en vez de una +// biblioteca. +package main + +// La instrucción `import` declara los paquetes de bibliotecas referidos +// en este fichero. +import ( + "fmt" // Un paquete en la biblioteca estándar de Go. + "io/ioutil" // Implementa algunas útiles funciones de E/S. + m "math" // Biblioteca de matemáticas con alias local m. + "net/http" // Sí, ¡un servidor web! + "strconv" // Conversiones de cadenas. +) + +// Definición de una función. `main` es especial. Es el punto de entrada +// para el ejecutable. Te guste o no, Go utiliza llaves. +func main() { + // Println imprime una línea a stdout. + // Cualificalo con el nombre del paquete, fmt. + fmt.Println("¡Hola mundo!") + + // Llama a otra función de este paquete. + másAlláDelHola() +} + +// Las funciones llevan parámetros entre paréntesis. +// Si no hay parámetros, los paréntesis siguen siendo obligatorios. +func másAlláDelHola() { + var x int // Declaración de una variable. + // Las variables se deben declarar antes de utilizarlas. + x = 3 // Asignación de variable. + // Declaración "corta" con := para inferir el tipo, declarar y asignar. + y := 4 + suma, producto := aprendeMúltiple(x, y) // La función devuelve dos + // valores. + fmt.Println("suma:", suma, "producto:", producto) // Simple salida. + aprendeTipos() // < y minutos, ¡aprende más! +} + +// Las funciones pueden tener parámetros y (¡múltiples!) valores de +// retorno. +func aprendeMúltiple(x, y int) (suma, producto int) { + return x + y, x * y // Devuelve dos valores. +} + +// Algunos tipos incorporados y literales. +func aprendeTipos() { + // La declaración corta suele darte lo que quieres. + s := "¡Aprende Go!" // tipo cadena. + s2 := `Un tipo cadena "puro" puede incluir +saltos de línea.` // mismo tipo cadena + + // Literal no ASCII. Los ficheros fuente de Go son UTF-8. + g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter unicode. + f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit. + c := 3 + 4i // complex128, representado internamente por dos float64. + // Sintaxis Var con iniciadores. + var u uint = 7 // Sin signo, pero la implementación depende del tamaño + // como en int. + var pi float32 = 22. / 7 + + // Sintáxis de conversión con una declaración corta. + n := byte('\n') // byte es un alias para uint8. + + // Los Arreglos tienen un tamaño fijo a la hora de compilar. + var a4 [4]int // Un arreglo de 4 ints, iniciados a 0. + a3 := [...]int{3, 1, 5} // Un arreglo iniciado con un tamaño fijo de tres + // elementos, con valores 3, 1 y 5. + // Los Sectores tienen tamaño dinámico. Los arreglos y sectores tienen + // sus ventajas y desventajas pero los casos de uso para los sectores + // son más comunes. + s3 := []int{4, 5, 9} // Comparar con a3. No hay puntos suspensivos. + s4 := make([]int, 4) // Asigna sectores de 4 ints, iniciados a 0. + var d2 [][]float64 // Solo declaración, sin asignación. + bs := []byte("a sector") // Sintaxis de conversión de tipo. + // Debido a que son dinámicos, los sectores pueden crecer bajo demanda. + // Para añadir elementos a un sector, se utiliza la función incorporada + // append(). + // El primer argumento es el sector al que se está anexando. Comúnmente, + // la variable del arreglo se actualiza en su lugar, como en el + // siguiente ejemplo. + sec := []int{1, 2 , 3} // El resultado es un sector de longitud 3. + sec = append(sec, 4, 5, 6) // Añade 3 elementos. El sector ahora tiene una + // longitud de 6. + fmt.Println(sec) // El sector actualizado ahora es [1 2 3 4 5 6] + // Para anexar otro sector, en lugar de la lista de elementos atómicos + // podemos pasar una referencia a un sector o un sector literal como + // este, con elipsis al final, lo que significa tomar un sector y + // desempacar sus elementos, añadiéndolos al sector sec. + sec = append(sec, []int{7, 8, 9} ...) // El segundo argumento es un + // sector literal. + fmt.Println(sec) // El sector actualizado ahora es [1 2 3 4 5 6 7 8 9] + p, q := aprendeMemoria() // Declara p, q para ser un tipo puntero a + // int. + fmt.Println(*p, *q) // * sigue un puntero. Esto imprime dos ints. + + // Los Mapas son arreglos asociativos dinámicos, como los hash o + // diccionarios de otros lenguajes. + m := map[string]int{"tres": 3, "cuatro": 4} + m["uno"] = 1 + + // Las variables no utilizadas en Go producen error. + // El guión bajo permite "utilizar" una variable, pero descartar su + // valor. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Esto cuenta como utilización de variables. + fmt.Println(s, c, a4, s3, d2, m) + + aprendeControlDeFlujo() // Vuelta al flujo. +} + +// Es posible, a diferencia de muchos otros lenguajes tener valores de +// retorno con nombre en las funciones. +// Asignar un nombre al tipo que se devuelve en la línea de declaración de +// la función nos permite volver fácilmente desde múltiples puntos en una +// función, así como sólo utilizar la palabra clave `return`, sin nada +// más. +func aprendeRetornosNombrados(x, y int) (z int) { + z = x * y + return // aquí z es implícito, porque lo nombramos antes. +} + +// Go posee recolector de basura. Tiene punteros pero no aritmética de +// punteros. Puedes cometer errores con un puntero nil, pero no +// incrementando un puntero. +func aprendeMemoria() (p, q *int) { + // Los valores de retorno nombrados q y p tienen un tipo puntero + // a int. + p = new(int) // Función incorporada que reserva memoria. + // La asignación de int se inicia a 0, p ya no es nil. + s := make([]int, 20) // Reserva 20 ints en un solo bloque de memoria. + s[3] = 7 // Asigna uno de ellos. + r := -2 // Declara otra variable local. + return &s[3], &r // & toma la dirección de un objeto. +} + +func cálculoCaro() float64 { + return m.Exp(10) +} + +func aprendeControlDeFlujo() { + // La declaración If requiere llaves, pero no paréntesis. + if true { + fmt.Println("ya relatado") + } + // El formato está estandarizado por la orden "go fmt." + if false { + // Abadejo. + } else { + // Relamido. + } + // Utiliza switch preferentemente para if encadenados. + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Los cases no se mezclan, no requieren de "break". + case 43: + // No llega. + } + // Como if, for no utiliza paréntesis tampoco. + // Variables declaradas en for e if son locales a su ámbito. + for x := 0; x < 3; x++ { // ++ es una instrucción. + fmt.Println("iteración", x) + } + // aquí x == 42. + + // For es la única instrucción de bucle en Go, pero tiene formas + // alternativas. + for { // Bucle infinito. + break // ¡Solo bromeaba! + continue // No llega. + } + + // Puedes usar `range` para iterar en un arreglo, un sector, una + // cadena, un mapa o un canal. + // `range` devuelve o bien, un canal o de uno a dos valores (arreglo, + // sector, cadena y mapa). + for clave, valor := range map[string]int{"uno": 1, "dos": 2, "tres": 3} { + // por cada par en el mapa, imprime la clave y el valor + fmt.Printf("clave=%s, valor=%d\n", clave, valor) + } + + // Como en for, := en una instrucción if significa declarar y asignar + // primero, luego comprobar y > x. + if y := cálculoCaro(); y > x { + x = y + } + // Las funciones literales son "cierres". + granX := func() bool { + return x > 100 // Referencia a x declarada encima de la instrucción + // switch. + } + fmt.Println("granX:", granX()) // cierto (la última vez asignamos + // 1e6 a x). + x /= 1.3e3 // Esto hace a x == 1300 + fmt.Println("granX:", granX()) // Ahora es falso. + + // Es más las funciones literales se pueden definir y llamar en línea, + // actuando como un argumento para la función, siempre y cuando: + // a) la función literal sea llamada inmediatamente (), + // b) el tipo del resultado sea del tipo esperado del argumento + fmt.Println("Suma dos números + doble: ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Llamada con argumentos 10 y 2 + // => Suma dos números + doble: 24 + + // Cuando lo necesites, te encantará. + goto encanto +encanto: + + aprendeFunciónFábrica() // func devolviendo func es divertido(3)(3) + aprendeADiferir() // Un rápido desvío a una importante palabra clave. + aprendeInterfaces() // ¡Buen material dentro de poco! +} + +func aprendeFunciónFábrica() { + // Las dos siguientes son equivalentes, la segunda es más práctica + fmt.Println(instrucciónFábrica("día")("Un bello", "de verano")) + + d := instrucciónFábrica("atardecer") + fmt.Println(d("Un hermoso", "de verano")) + fmt.Println(d("Un maravilloso", "de verano")) +} + +// Los decoradores son comunes en otros lenguajes. Lo mismo se puede hacer +// en Go con funciónes literales que aceptan argumentos. +func instrucciónFábrica(micadena string) func(antes, después string) string { + return func(antes, después string) string { + return fmt.Sprintf("¡%s %s %s!", antes, micadena, después) // nueva cadena + } +} + +func aprendeADiferir() (ok bool) { + // las instrucciones diferidas se ejecutan justo antes de que la + // función regrese. + defer fmt.Println("las instrucciones diferidas se ejecutan en orden inverso (PEPS).") + defer fmt.Println("\nEsta línea se imprime primero debido a que") + // Defer se usa comunmente para cerrar un fichero, por lo que la + // función que cierra el fichero se mantiene cerca de la función que lo + // abrió. + return true +} + +// Define Stringer como un tipo interfaz con un método, String. +type Stringer interface { + String() string +} + +// Define par como una estructura con dos campos int, x e y. +type par struct { + x, y int +} + +// Define un método en el tipo par. Par ahora implementa a Stringer. +func (p par) String() string { // p se conoce como el "receptor" + // Sprintf es otra función pública del paquete fmt. + // La sintaxis con punto se refiere a los campos de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func aprendeInterfaces() { + // La sintaxis de llaves es una "estructura literal". Evalúa a una + // estructura iniciada. La sintaxis := declara e inicia p a esta + // estructura. + p := par{3, 4} + fmt.Println(p.String()) // Llama al método String de p, de tipo par. + var i Stringer // Declara i como interfaz de tipo Stringer. + i = p // Válido porque par implementa Stringer. + // Llama al metodo String de i, de tipo Stringer. Misma salida que + // arriba. + fmt.Println(i.String()) + + // Las funciones en el paquete fmt llaman al método String para + // consultar un objeto por una representación imprimible de si + // mismo. + fmt.Println(p) // Salida igual que arriba. Println llama al método + // String. + fmt.Println(i) // Salida igual que arriba. + aprendeNúmeroVariableDeParámetros("¡gran", "aprendizaje", "aquí!") +} + +// Las funciones pueden tener número variable de argumentos. +func aprendeNúmeroVariableDeParámetros(misCadenas ...interface{}) { + // Itera en cada valor de los argumentos variables. + // El espacio en blanco aquí omite el índice del argumento arreglo. + for _, parámetro := range misCadenas { + fmt.Println("parámetro:", parámetro) + } + + // Pasa el valor de múltiples variables como parámetro variadic. + fmt.Println("parámetros:", fmt.Sprintln(misCadenas...)) + aprendeManejoDeError() +} + +func aprendeManejoDeError() { + // ", ok" forma utilizada para saber si algo funcionó o no. + m := map[int]string{3: "tres", 4: "cuatro"} + if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el mapa. + fmt.Println("nada allí") + } else { + fmt.Print(x) // x sería el valor, si estuviera en el mapa. + } + // Un valor de error comunica más información sobre el problema aparte + // de "ok". + if _, err := strconv.Atoi("no-int"); err != nil { // _ descarta el + // valor + // Imprime "strconv.ParseInt: parsing "no-int": invalid syntax". + fmt.Println(err) + } + // Revisaremos las interfaces más adelante. Mientras tanto... + aprendeConcurrencia() +} + +// c es un canal, un objeto de comunicación concurrente seguro. +func inc(i int, c chan int) { + c <- i + 1 // <- es el operador "enviar" cuando aparece un canal a la + // izquierda. +} + +// Utilizaremos inc para incrementar algunos números concurrentemente. +func aprendeConcurrencia() { + // Misma función make utilizada antes para crear un sector. Make asigna + // e inicia sectores, mapas y canales. + c := make(chan int) + // Inicia tres rutinasgo concurrentes. Los números serán incrementados + // concurrentemente, quizás en paralelo si la máquina es capaz y está + // correctamente configurada. Las tres envían al mismo canal. + go inc(0, c) // go es una instrucción que inicia una nueva rutinago. + go inc(10, c) + go inc(-805, c) + // Lee los tres resultados del canal y los imprime. + // ¡No se puede saber en que orden llegarán los resultados! + fmt.Println(<-c, <-c, <-c) // Canal a la derecha, <- es el operador + // "recibe". + + cs := make(chan string) // Otro canal, este gestiona cadenas. + ccs := make(chan chan string) // Un canal de canales cadena. + go func() { c <- 84 }() // Inicia una nueva rutinago solo para + // enviar un valor. + go func() { cs <- "verboso" }() // Otra vez, para cs en esta ocasión. + // Select tiene una sintáxis parecida a la instrucción switch pero cada + // caso involucra una operacion con un canal. Selecciona un caso de + // forma aleatoria de los casos que están listos para comunicarse. + select { + case i := <-c: // El valor recibido se puede asignar a una variable, + fmt.Printf("es un %T", i) + case <-cs: // o el valor se puede descartar. + fmt.Println("es una cadena") + case <-ccs: // Canal vacío, no está listo para la comunicación. + fmt.Println("no sucedió.") + } + + // En este punto un valor fue devuelto de c o cs. Una de las dos + // rutinasgo que se iniciaron se ha completado, la otrá permancerá + // bloqueada. + + aprendeProgramaciónWeb() // Go lo hace. Tú también quieres hacerlo. +} + +// Una simple función del paquete http inicia un servidor web. +func aprendeProgramaciónWeb() { +// El primer parámetro es la direccinón TCP a la que escuchar. + // El segundo parámetro es una interfaz, concretamente http.Handler. + go func() { + err := http.ListenAndServe(":8080", par{}) + fmt.Println(err) // no ignora errores + }() + consultaAlServidor() +} + +// Hace un http.Handler de par implementando su único método, ServeHTTP. +func (p par) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Sirve datos con un método de http.ResponseWriter. + w.Write([]byte("¡Aprendiste Go en Y minutos!")) +} + +func consultaAlServidor() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + cuerpo, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nEl servidor web dijo: `%s`\n", string(cuerpo)) +} +``` + +## Más información + +La raíz de todas las cosas sobre Go es el +[sitio web oficial de Go](http://golang.org/). +Allí puedes seguir el tutorial, jugar interactivamente y leer mucho más. + +La definición del lenguaje es altamente recomendada. Es fácil de leer y +sorprendentemente corta (como la definición del lenguaje Go en estos +días). + +Puedes jugar con el código en el +[parque de diversiones Go](https://play.golang.org/p/ncRC2Zevag). ¡Trata +de cambiarlo y ejecutarlo desde tu navegador! Ten en cuenta que puedes +utilizar [https://play.golang.org]( https://play.golang.org) como un +[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) para probar +cosas y el código en el navegador, sin ni siquiera instalar Go. + +En la lista de lecturas para estudiantes de Go está el +[código fuente de la biblioteca estándar](http://golang.org/src/pkg/). +Ampliamente documentado, que demuestra lo mejor del legible y comprensible +Go, con su característico estilo y modismos. ¡O puedes hacer clic en un +nombre de función en [la documentación](http://golang.org/pkg/) y +aparecerá el código fuente! + +Otro gran recurso para aprender Go está en +[Go con ejemplos](http://goconejemplos.com/). diff --git a/es-es/haml-es.html.markdown b/es-es/haml-es.html.markdown new file mode 100644 index 00000000..be90b8f3 --- /dev/null +++ b/es-es/haml-es.html.markdown @@ -0,0 +1,159 @@ +--- +language: haml +filename: learnhaml-es.haml +contributors: + - ["Simon Neveu", "https://github.com/sneveu"] +translators: + - ["Camilo Garrido", "http://www.twitter.com/hirohope"] +lang: es-es +--- + +Haml es un lenguage de marcas principalmente usado con Ruby, que de forma simple y limpia describe el HTML de cualquier documento web sin el uso de código en linea. Es una alternativa popular respecto a usar el lenguage de plantilla de Rails (.erb) y te permite embeber código Ruby en tus anotaciones. + +Apunta a reducir la repetición en tus anotaciones cerrando los tags por ti, basándose en la estructura de identación de tu código. El resultado es una anotación bien estructurada, que no se repite, lógica y fácil de leer. + +También puedes usar Haml en un proyecto independiente de Ruby, instalando la gema Haml en tu máquina y usando la línea de comandos para convertirlo en html. + +$ haml archivo_entrada.haml archivo_salida.html + + +```haml +/ ------------------------------------------- +/ Identación +/ ------------------------------------------- + +/ + Por la importancia que la identación tiene en cómo tu código es traducido, + la identación debe ser consistente a través de todo el documento. Cualquier + diferencia en la identación lanzará un error. Es una práctica común usar dos + espacios, pero realmente depende de tí, mientras sea consistente. + + +/ ------------------------------------------- +/ Comentarios +/ ------------------------------------------- + +/ Así es como un comentario se ve en Haml. + +/ + Para escribir un comentario multilínea, identa tu código a comentar de tal forma + que sea envuelto por por una barra. + + +-# Este es un comentario silencioso, significa que no será traducido al código en absoluto + + +/ ------------------------------------------- +/ Elementos Html +/ ------------------------------------------- + +/ Para escribir tus tags, usa el signo de porcentaje seguido por el nombre del tag +%body + %header + %nav + +/ Nota que no hay tags de cierre. El código anterior se traduciría como + <body> + <header> + <nav></nav> + </header> + </body> + +/ El tag div es un elemento por defecto, por lo que pueden ser escritos simplemente así +.foo + +/ Para añadir contenido a un tag, añade el texto directamente después de la declaración +%h1 Headline copy + +/ Para escribir contenido multilínea, anídalo. +%p + Esto es mucho contenido que podríamos dividirlo en dos + líneas separadas. + +/ + Puedes escapar html usando el signo ampersand y el signo igual ( &= ). + Esto convierte carácteres sensibles en html a su equivalente codificado en html. + Por ejemplo + +%p + &= "Sí & si" + +/ se traduciría en 'Sí & si' + +/ Puedes desescapar html usando un signo de exclamación e igual ( != ) +%p + != "Así es como se escribe un tag párrafo <p></p>" + +/ se traduciría como 'Así es como se escribe un tag párrafo <p></p>' + +/ Clases CSS puedes ser añadidas a tus tags, ya sea encadenando .nombres-de-clases al tag +%div.foo.bar + +/ o como parte de un hash Ruby +%div{:class => 'foo bar'} + +/ Atributos para cualquier tag pueden ser añadidos en el hash +%a{:href => '#', :class => 'bar', :title => 'Bar'} + +/ Para atributos booleanos asigna el valor verdadero 'true' +%input{:selected => true} + +/ Para escribir atributos de datos, usa la llave :dato con su valor como otro hash +%div{:data => {:attribute => 'foo'}} + + +/ ------------------------------------------- +/ Insertando Ruby +/ ------------------------------------------- + +/ + Para producir un valor Ruby como contenido de un tag, usa un signo igual + seguido por código Ruby + +%h1= libro.nombre + +%p + = libro.autor + = libro.editor + + +/ Para correr un poco de código Ruby sin traducirlo en html, usa un guión +- libros = ['libro 1', 'libro 2', 'libro 3'] + +/ Esto te permite hacer todo tipo de cosas asombrosas, como bloques de Ruby +- libros.shuffle.each_with_index do |libro, indice| + %h1= libro + + if libro do + %p Esto es un libro + +/ + Nuevamente, no hay necesidad de añadir los tags de cerrado en el código, ni siquiera para Ruby + La identación se encargará de ello por tí. + + +/ ------------------------------------------- +/ Ruby en linea / Interpolación de Ruby +/ ------------------------------------------- + +/ Incluye una variable Ruby en una línea de texto plano usando #{} +%p Tu juego con puntaje más alto es #{mejor_juego} + + +/ ------------------------------------------- +/ Filtros +/ ------------------------------------------- + +/ + Usa un signo dos puntos para definir filtros Haml, un ejemplo de filtro que + puedes usar es :javascript, el cual puede ser usado para escribir javascript en línea. + +:javascript + console.log('Este es un <script> en linea'); + +``` + +## Recusros adicionales + +- [¿Qué es HAML? (en inglés)](http://haml.info/) - Una buena introducción que hace mejor el trabajo de explicar los beneficios de usar haml. +- [Documentación Oficial (en inglés)](http://haml.info/docs/yardoc/file.REFERENCE.html) - Si deseas ir un poco más profundo. diff --git a/es-es/java-es.html.markdown b/es-es/java-es.html.markdown new file mode 100644 index 00000000..b34dca8d --- /dev/null +++ b/es-es/java-es.html.markdown @@ -0,0 +1,410 @@ +--- +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["Camilo Garrido", "http://www.twitter.com/hirohope"] +lang: es-es +filename: LearnJava-es.java +--- + +Java es un lenguage de programación de propósito general, concurrente, basado en clases y +orientado a objetos. +[Lee más aquí.](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// Comentarios de una sóla línea comienzan con // +/* +Comentarios multilínea lucen así +*/ +/** +Comentarios JavaDoc lucen así. Suelen describir la clase o varios atributos +de una clase. +*/ + +// Importa la clase ArrayList dentro del paquete java.util +import java.util.ArrayList; +// Importa todas las clases dentro del paquete java.security +import java.security.*; + +// Cada archivo .java contiene una clase pública, con el mismo nombre del archivo. +public class AprendeJava { + + // Un programa debe tener un método 'main' como punto de entrada + public static void main (String[] args) { + + // Usa System.out.println para imprimir líneas + System.out.println("¡Hola mundo!"); + System.out.println( + "Entero (int): " + 10 + + " Doble (double): " + 3.14 + + " Booleano (boolean): " + true); + + // Para imprimir sin el salto de línea, usa System.out.print + System.out.print("Hola "); + System.out.print("Mundo"); + + + /////////////////////////////////////// + // Tipos & Variables + /////////////////////////////////////// + + // Declara una variable usando <tipo> <nombre> [ + // Byte - Entero complemento a dos con signo de 8-bit + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - Entero complemento a dos con signo de 16-bit + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - Entero complemento a dos con signo de 32-bit + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - Entero complemento a dos con signo de 64-bit + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L es usado para denotar que el valor de esta variable es del tipo Long; + // cualquier cosa sin ella es tratado como un entero por defecto. + + // Nota: Java no tiene tipos sin signo + + // Float - Número de coma flotante IEEE 754 de precisión simple de 32-bit + float fooFloat = 234.5f; + // f es usado para denotar qeu el valor de esta variable es del tipo float; + // de otra manera es tratado como un double. + + // Double - Número de coma flotante IEEE 754 de precisión doble de 64-bit + double fooDouble = 123.4; + + // Boolean - true & false + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - Un simple carácter unicode de 16-bit + char fooChar = 'A'; + + // Usa 'final' para hacer inmutable las variables + final int HORAS_QUE_TRABAJO_POR_SEMANA = 9001; + + // Strings + String fooString = "¡Mi String está aquí!"; + + // \n es un carácter escapado que inicia una nueva línea + String barString = "¿Imprimiendo en una nueva linea?\n¡Ningun problema!"; + // \t es un carácter escapado que añade un carácter tab + String bazString = "¿Quieres añadir un 'tab'?\t¡Ningun problema!"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // Arreglos + //El tamaño del arreglo debe decidirse en la declaración + //El formato para la declaración de un arreglo es la siguiente: + //<tipo_de_dato> [] <nombre_variable> = new <tipo_de_dato>[<tamaño_arreglo>]; + int [] arreglo_de_enteros = new int[10]; + String [] arreglo_de_strings = new String[1]; + boolean [] arreglo_de_booleanos = new boolean[100]; + + // Otra forma de declarar & inicializar un arreglo + int [] y = {9000, 1000, 1337}; + + // Indexación de un arreglo - Accediendo un elemento + System.out.println("arreglo_de_enteros @ 0: " + arreglo_de_enteros[0]); + + // Arreglos comienzan su indexación en cero y son mutables + arreglo_de_enteros[1] = 1; + System.out.println("arreglo_de_enteros @ 1: " + arreglo_de_enteros[1]); // => 1 + + // Otros para echar un vistazo + // ArrayLists - Son como arreglos excepto que ofrecen más funcionalidades + // y el tamaño es mutable + // LinkedLists + // Maps + // HashMaps + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + System.out.println("\n->Operadores"); + + int i1 = 1, i2 = 2; // Abreviación para múltiples declaraciones + + // La aritmética es directa + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncado) + + // Módulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Operadores de comparación + System.out.println("3 == 2? " + (3 == 2)); // => false + System.out.println("3 != 2? " + (3 != 2)); // => true + System.out.println("3 > 2? " + (3 > 2)); // => true + System.out.println("3 < 2? " + (3 < 2)); // => false + System.out.println("2 <= 2? " + (2 <= 2)); // => true + System.out.println("2 >= 2? " + (2 >= 2)); // => true + + // ¡Operaciones a nivel de bits! + /* + ~ Complemento unario bit a bit + << Deplazamiento hacia la izquierda con signo + >> Deplazamiento hacia la derecha con signo + >>> Deplazamiento hacia la derecha sin signo + & AND lógico + ^ OR lógico exclusivo + | OR lógico inclusivo + */ + + // Incrementos + int i = 0; + System.out.println("\n->Incrementos y reducciones"); + System.out.println(i++); //i = 1. Post-incremento + System.out.println(++i); //i = 2. Pre-incremento + System.out.println(i--); //i = 1. Post-reducción + System.out.println(--i); //i = 0. Pre-reducción + + /////////////////////////////////////// + // Estructuras de Control + /////////////////////////////////////// + System.out.println("\n->Estructuras de Control"); + + // Condiciones 'if' son como en c + int j = 10; + if (j == 10){ + System.out.println("Me imprimieron"); + } else if (j > 10) { + System.out.println("A mi no"); + } else { + System.out.println("A mi tampoco"); + } + + // Ciclos 'while' + int fooWhile = 0; + while(fooWhile < 100) + { + //System.out.println(fooWhile); + //Incrementar el contador + //Iteró 99 veces, fooWhile 0->99 + fooWhile++; + } + System.out.println("Valor fooWhile: " + fooWhile); + + // Ciclos 'do while' + int fooDoWhile = 0; + do + { + //System.out.println(fooDoWhile); + //Incrementar el contador + //Iteró 99 veces, fooDoWhile 0->99 + fooDoWhile++; + }while(fooDoWhile < 100); + System.out.println("Valor fooDoWhile: " + fooDoWhile); + + // Ciclos 'for' + int fooFor; + //Estructura del ciclo 'for' => for(<declaración_de_inicio>; <condicional>; <paso>) + for(fooFor=0; fooFor<10; fooFor++){ + //System.out.println(fooFor); + //Iteró 10 veces, fooFor 0->9 + } + System.out.println("Valor fooFor: " + fooFor); + + // Switch Case + // Un 'switch' funciona con un tipo de dato byte, short, char e int + // También funciona con tipos enumerados (discutido en tipos Enum), + // la clase String y unas pocas clases especiales que envuelven + // tipos primitivos: Character, Byte, Short e Integer. + int mes = 3; + String mesString; + switch (mes){ + case 1: + mesString = "Enero"; + break; + case 2: + mesString = "Febrero"; + break; + case 3: + mesString = "Marzo"; + break; + default: + mesString = "Algun otro mes"; + break; + } + System.out.println("Resultado switch Case: " + mesString); + + + /////////////////////////////////////// + // Convirtiendo Tipos de Datos y Conversión de Tipos + /////////////////////////////////////// + + // Convirtiendo datos + + // Convertir String a Integer + Integer.parseInt("123");//retorna una versión entera de "123" + + // Convertir Integer a String + Integer.toString(123);//retorna una versión string de 123 + + // Para otras conversiones fíjate en las siguientes clases + // Double + // Long + // String + + // Conversión de tipos + // También puedes convertir objetos java, hay muchos detalles + // con unos pocos conceptos intermedios + // No dudes en verlos acá + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Clases y Funciones + /////////////////////////////////////// + + System.out.println("\n->Clases & Funciones"); + + // (A continuación la definición de una clase Bicicleta) + + // Usa 'new' para instanciar una clase + Bicicleta excursion = new Bicicleta(); + + // Llama métodos del objeto + excursion.aumentarVelocidad(3); // Siempre deberías usar metodos 'set' (establecer) y 'get' (obtener) + excursion.setRitmo(100); + + // 'toString' es una convención para mostrar los valores de este objeto. + System.out.println("informacion de la excursion: " + excursion.toString()); + + } // Fin del método 'main' +} // Fin de la clase AprendeJava + + +// Puedes incluir otras clases no públicas en un archivo .java + + +// Sintaxis de declaración de clases: +// <public/private/protected> class <nombre_de_la_clase>{ +// //variables_de_clase, constructores, todas las funciones. +// //las funciones son llamadas como métodos en Java. +// } + +class Bicicleta { + + // Campos/Variables de Bicicleta + public int ritmo; // Public: Puede ser accedido desde cualquier parte + private int velocidad; // Private: Accesible sólo desde esta clase + protected int engranaje; // Protected: Accesible desde esta clases y sus subclases + String nombre; // default: Sólo accesible desde este paquete + + // Constructores son la manera de crear clases + // Este es un constructor por defecto + public Bicicleta() { + engranaje = 1; + ritmo = 50; + velocidad = 5; + nombre = "Bontrager"; + } + + // Este es un constructor específico (contiene argumentos) + public Bicicleta(int ritmoInicial, int velocidadInicial, int engranajeInicial, String nombre) { + this.engranaje = engranajeInicial; + this.ritmo = ritmoInicial; + this.velocidad = velocidadInicial; + this.nombre = nombre; + } + + // Sintaxis de función: + // <public/private/protected> <tipo_de_retorno> <nombre_funcion>(<argumentos>) + + // Las clases de Java usualmente implementan métodos 'get' (obtener) y 'set' (establecer) para sus campos + + // Sintaxis de declaración de métodos + // <alcance> <tipo_de_retorno> <nombre_metodo>(<argumentos>) + public int getRitmo() { + return ritmo; + } + + // Métodos void no requieren retornar + public void setRitmo(int nuevoValor) { + ritmo = nuevoValor; + } + + public void setEngranaje(int nuevoValor) { + engranaje = nuevoValor; + } + + public void aumentarVelocidad(int incremento) { + velocidad += incremento; + } + + public void disminuirVelocidad(int reduccion) { + velocidad -= reduccion; + } + + public void setNombre(String nuevoNombre) { + nombre = nuevoNombre; + } + + public String getNombre() { + return nombre; + } + + //Método para mostrar los valores de los atributos de este objeto. + @Override + public String toString() { + return "engranaje: " + engranaje + + " ritmo: " + ritmo + + " velocidad: " + velocidad + + " nombre: " + nombre; + } +} // fin clase Bicicleta + +// PennyFarthing es una subclase de Bicicleta +class PennyFarthing extends Bicicleta { + // (Penny Farthings son esas bicicletas con una gran rueda forntal. + // No tienen engranajes.) + + public PennyFarthing(int ritmoInicial, int velocidadInicial){ + // Llama al constructor del padre con super + super(ritmoInicial, velocidadInicial, 0, "PennyFarthing"); + } + + // Deberías marcar un método que estás sobre escribiendo con una @anotacion + // Para aprender más sobre que son y el propósito de las anotaciones + // echa un vistazo acá: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setEngranaje(int engranaje) { + engranaje = 0; + } + +} + +``` + +## Más Lectura + +Estos links son sólo para tener un entendimiento del tema, no dudes en +usar Google y encontrar ejemplos más específicos + +Otros temas a investigar: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown new file mode 100644 index 00000000..036d7082 --- /dev/null +++ b/es-es/javascript-es.html.markdown @@ -0,0 +1,528 @@ +--- +language: javascript +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +translators: + - ["Daniel Zendejas","https://github.com/DanielZendejas"] +filename: javascript-es.js +lang: es-es +--- +Tutorial de JavaScript en español. + +JavaScript fue creado por Brendan Eich en 1995 mientras trabajaba en Netscape. +Su intención original era crear un lenguaje simple para sitios web, complementándolo +con Java para aplicaciones más complejas. Debido a su integracion estrecha con sitios +web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común +para front-end que Java. + +JavaScript no sólo se limita a los navegadores web, aunque: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular. + +¡La retroalimentación es bienvenida! Puedes encontrarme en: +[@adambrenecki](https://twitter.com/adambrenecki), o +[adam@brenecki.id.au](mailto:adam@brenecki.id.au). + +```js +// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //, +/* y los comentarios multilínea comienzan + y terminan con */ + +// Cada sentencia puede ser terminada con punto y coma ; +hazAlgo(); + +// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente +// cada que se detecta una nueva línea, a excepción de algunos casos. +hazAlgo() + +// Dado que esta práctica puede llevar a resultados inesperados, seguiremos agregando +// punto y coma en esta guía. + +/////////////////////////////////// +// 1. Números, Strings y Operadores + +// JavaScript tiene un solo tipo de número (doble de 64-bit IEEE 754). +// Así como con Lua, no te espantes por la falta de enteros: los dobles tienen 52 bits +// de mantisa, lo cual es suficiente para guardar enteros de hasta 9✕10¹⁵. +3; // = 3 +1.5; // = 1.5 + +// Toda la aritmética básica funciona como uno esperaría. +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Incluyendo divisiones con resultados no enteros. +5 / 2; // = 2.5 + +// Las operaciones con bits también funcionan; cuando ejecutas una operación con bits +// el número flotante se convierte a entero con signo *hasta* 32 bits. +1 << 2; // = 4 + +// La jerarquía de las operaciones se aplica con paréntesis. +(1 + 3) * 2; // = 8 + +// Hay tres casos especiales de valores con los números: +Infinity; // por ejemplo: 1/0 +-Infinity; // por ejemplo: -1/0 +NaN; // por ejemplo: 0/0 + +// También hay booleanos: +true; +false; + +// Los Strings se pueden crear con ' o ". +'abc'; +"Hola, mundo"; + +// La negación se aplica con la expresión ! +!true; // = false +!false; // = true + +// Para comprobar una igualdad se usa == +1 == 1; // = true +2 == 1; // = false + +// Para comprobar una desigualdad se usa != +1 != 1; // = false +2 != 1; // = true + +// Más comparaciones +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Los Strings se concatenan con + +"¡Hola " + "mundo!"; // = "¡Hola mundo!" + +// y se comparan con < y con > +"a" < "b"; // = true + +// Los tipos no importan con el operador ==... +"5" == 5; // = true +null == undefined; // = true + +// ...a menos que uses === +"5" === 5; // = false +null === undefined; // false + +// Los Strings funcionan como arreglos de caracteres +// Puedes accesar a cada caracter con la función charAt() +"Este es un String".charAt(0); // = 'E' + +// ...o puedes usar la función substring() para acceder a pedazos más grandes +"Hola Mundo".substring(0, 4); // = "Hola" + +// length es una propiedad, así que no uses () +"Hola".length; // = 4 + +// También hay null y undefined +null; // usado para indicar una falta de valor deliberada +undefined; // usado para indicar que un valor no está presente actualmente + // (aunque undefined es un valor en sí mismo) + +// false, null, undefined, NaN, 0 y "" es false; todo lo demás es true. +// Note que 0 is false y "0" es true, a pesar de que 0 == "0". +// Aunque 0 === "0" sí es false. + +/////////////////////////////////// +// 2. Variables, Arrays y Objetos + +// Las variables se declaran con la palabra var. JavaScript cuenta con tipado dinámico, +// así que no se necesitan aplicar tipos. La asignación se logra con el operador =. +var miPrimeraVariable = 5; + +// si no escribes la palabra var no se marcará ningún error... +miSegundaVariable = 10; + +// ...pero tu variable se declarará en el ámbito global, no en el ámbito +// en el que se definió. + +// Las variables que no están aún asignadas tienen el valor undefined. +var miTerceraVariable; // = undefined + +// Existen atajos para realizar operaciones aritméticas: +miPrimeraVariable += 5; // equivalente a miPrimeraVariable = miPrimeraVariable + 5; + // miPrimeraVariable ahora es 10 +miPrimeraVariable *= 10; // ahora miPrimeraVariable es 100 + +// Y atajos aún más cortos para sumar y restar 1 +miPrimeraVariable++; // ahora miPrimeraVariable es 101 +miPrimeraVariable--; // de vuelta a 100 + +// Los arreglos son listas ordenadas de valores, de cualquier tipo. +var miArreglo = ["Hola", 45, true]; + +// Los miembros de un arreglo pueden ser accesados con la sintaxis +// de indices dentro de corchetes []. +// Los índices empiezan en cero. +miArreglo[1]; // = 45 + +// Los arreglos son mutables y pueden cambiar de longitud. +miArreglo.push("Mundo"); +miArreglo.length; // = 4 + +// Agregar/Modificar en un determinado índice +miArreglo[3] = "Hola"; + +// Los objetos en JavaScript son equivalentes a los 'diccionarios' o 'mapas' en otros +// lenguajes: una colección de pares llave/valor desordenada. +var miObjeto = {llave1: "Hola", llave2: "Mundo"}; + +// Las llaves son strings, pero no se necesitan las comillas si son un identificador +// válido de JavaScript. Los valores pueden ser de cualquier tipo. +var miObjeto = {miLlave: "miValor", "mi otra llave": 4}; + +// Los atributos de los objetos también pueden ser accesadas usando +// la sintaxis de corchetes, +miObjeto["mi otra llave"]; // = 4 + +// ... o usando la sintaxis de punto, dado que la llave es un identificador válido. +miObjeto.miLlave; // = "miValor" + +// Los objetos son mutables; los valores pueden ser cambiados y se pueden +// agregar nuevas llaves. +miObjeto.miTerceraLlave = true; + +// Si intentas accesar con una llave que aún no está asignada tendrás undefined. +miObjeto.miCuartaLlave; // = undefined + +/////////////////////////////////// +// 3. Lógica y estructura de control + +// La sintaxis de esta sección es casi idéntica a la de Java. + +// La estructura if funciona de la misma forma. +var contador = 1; +if (contador == 3){ + // evaluar si contador es igual a 3 +} else if (contador == 4){ + // evaluar si contador es igual a 4 +} else { + // evaluar si contador no es igual a 3 ni a 4 +} + +// De la misma forma la estructura while. +while (true){ + // ¡Loop infinito! +} + +// La estructura Do-while es igual al while, excepto que se ejecuta al menos una vez. +var input +do { + input = conseguirInput(); +} while (!esValido(input)) + +// la esctructura for es la misma que la de C y Java: +// inicialización; condición; iteración. +for (var i = 0; i < 5; i++){ + // correrá cinco veces +} + +// && es un "y" lógico, || es un "o" lógico +if (casa.tamano == "grande" && casa.color == "azul"){ + casa.contiene = "oso"; +} +if (color == "rojo" || color == "azul"){ + // el color es rojo o azul +} + +// && y || "corto circuito", lo cual es útil para establecer valores por defecto. +var nombre = otroNombre || "default"; + + +// la estructura switch usa === para sus comparaciones +// usa 'break' para terminar cada caso +// o los casos después del caso correcto serán ejecutados también. +calificacion = 'B'; +switch (calificacion) { + case 'A': + console.log("Excelente trabajo"); + break; + case 'B': + console.log("Buen trabajo"); + break; + case 'C': + console.log("Puedes hacerlo mejor"); + break; + default: + console.log("Muy mal"); + break; +} + + +/////////////////////////////////// +// 4. Funciones, ámbitos y closures + +// Las funciones en JavaScript son declaradas con la palabra clave "function". +function miFuncion(miArgumentoString){ + return miArgumentoString.toUpperCase(); //la funcion toUpperCase() vuelve todo + // el String a mayúsculas +} +miFuncion("foo"); // = "FOO" + +// Note que el valor a ser regresado debe estar en la misma línea que la +// palabra clave 'return', de otra forma la función siempre regresará 'undefined' +// debido a la inserción automática de punto y coma. +function miFuncion() +{ + return // <- punto y coma insertado aquí automáticamente + { + estaEsUna: 'propiedad' + } +} +miFuncion(); // = undefined al mandar a llamar la función + +// Las funciones en JavaScript son de primera clase, así que pueden ser asignadas +// a variables y pasadas a otras funciones como argumentos - por ejemplo: +function miFuncion(){ + // este código será llamado cada cinco segundos +} +setTimeout(miFuncion, 5000); +// Note: setTimeout no es parte de JS, pero lo puedes obtener de los browsers +// y Node.js. + +// Es posible declarar funciones sin nombre - se llaman funciones anónimas +// y se definen como argumentos de otras funciones. +setTimeout(function(){ + // este código se ejecuta cada cinco segundos +}, 5000); + +// JavaScript tiene ámbitos de funciones; las funciones tienen su propio ámbito pero +// otros bloques no. +if (true){ + var i = 5; +} +i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, pero no aquí. + +// Este conlleva a un patrón de diseño común llamado "ejecutar funciones anónimas +//inmediatamente", que preveé variables temporales de fugarse al ámbito global +(function(){ + var temporal = 5; + // Podemos accesar al ámbito global asignando al 'objeto global', el cual + // en un navegador siempre es 'window'. El objeto global puede tener + // un nombre diferente en ambientes distintos, por ejemplo Node.js . + window.permanente = 10; +})(); +temporal; // da ReferenceError +permanente; // = 10 + +// Una de las características más útiles de JavaScript son los closures. +// Si una función es definida dentro de otra función, la función interna tiene acceso +// a todas las variables de la función externa, incluso aunque la función +// externa ya haya terminado. +function decirHolaCadaCincoSegundos(nombre){ + var texto = "¡Hola, " + nombre + "!"; + // Las funciones internas son puestas en el ámbito local por defecto + // como si fueran declaradas con 'var'. + function interna(){ + alert(texto); + } + setTimeout(interna, 5000); + // setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos + // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos + // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene + // acceso a la variable 'texto' cuando es llamada. +} +decirHolaCadaCincoSegundos("Adam"); // mostrará una alerta con "¡Hola, Adam!" en 5s + +/////////////////////////////////// +// 5. Más sobre objetos; constructores y prototipos + +// Los objetos pueden contener funciones. +var miObjeto = { + miFuncion: function(){ + return "¡Hola Mundo!"; + } +}; +miObjeto.miFuncion(); // = "¡Hola Mundo!" + +// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables +// del objeto con la palabra clave 'this'. +miObjeto = { + miString: "¡Hola Mundo!", + miFuncion: function(){ + return this.miString; + } +}; +miObjeto.miFuncion(); // = "¡Hola Mundo!" + +// Las funciones de un objeto deben ser llamadas dentro del contexto de ese objeto. +var miFuncion = myObj.miFuncion; +miFuncion(); // = undefined + +// Una función puede ser asignada al objeto y ganar acceso a él gracias a esto, +// incluso si no estaba dentro del objeto cuando este se definió. +var miOtraFuncion = function(){ + return this.miString.toUpperCase(); +} +miObjeto.miOtraFuncion = myOtherFunc; +miObjeto.miOtraFuncion(); // = "¡HOLA MUNDO!" + +// Podemos especificar el contexto en el que una función será llamada con los comandos +// 'call' o 'apply'. + +var otraFuncion = function(otroString){ + return this.miString + otroString; +} +otraFuncion.call(miObjeto, " y hola Luna!"); // = "¡Hola Mundo! y hola Luna!" + +// 'apply' es casi idéntico, pero recibe un arreglo como argumento. + +otraFuncion.apply(miObjeto, [" y hola Sol!"]); // = "¡Hola Mundo! y hola Sol!" + +// Esto es útil cuando estás trabajando con una función que acepta una secuencia de +// argumentos y quieres pasar un arreglo. + +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Pero 'call' y 'apply' sólo son temporales. Cuando queremos que se quede, usamos bind. + +var funcionUnida = otraFuncion.bind(miObjeto); +funcionUnida(" y hola Saturno!"); // = "¡Hola Mundo! y hola Saturno!" + +// Bind también puede ser usada para aplicar parcialmente (curry) una función. + +var producto = function(a, b){ return a * b; } +var porDos = producto.bind(this, 2); +porDos(8); // = 16 + +// Cuando llamas a una función con la palabra clave 'new' un nuevo objeto es creado. +// Se hace disponible a la función. Las funciones diseñadas para ser usadas así se +// llaman constructores. + +var MiConstructor = function(){ + this.miNumero = 5; +} +miNuevoObjeto = new MiConstructor(); // = {miNumero: 5} +miNuevoObjeto.miNumero; // = 5 + +// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una +// propiedad en un objeto que no existe en el objeto el intérprete buscará en +// el prototipo. + +// Algunas implementaciones de JavaScript te permiten accesar al prototipo de +// un objeto con la propiedad __proto__. Mientras que esto es útil para explicar +// prototipos, no es parte del estándar; veremos formas estándar de usar prototipos +// más adelante. + +var miObjeto = { + miString: "¡Hola Mundo!" +}; +var miPrototipo = { + sentidoDeLaVida: 42, + miFuncion: function(){ + return this.miString.toLowerCase() + } +}; + +miObjeto.__proto__ = miPrototipo; +miObjeto.sentidoDeLaVida; // = 42 + +// Esto funcionan también para funciones. +miObjeto.miFuncion(); // = "hello world!" + +// Por supuesto, si la propiedad que buscas no está en el prototipo, +// se buscará en el prototipo del prototipo. +miPrototipo.__proto__ = { + miBoolean: true +}; +miObjeto.miBoolean; // = true + +// Esto no involucra ningún copiado, cada objeto guarda una referencia a su +// prototipo. Esto significa que podemos alterar el prototipo y nuestros +// cambios serán reflejados en todos lados. +miPrototipo.sentidoDeLaVida = 43; +miObjeto.sentidoDeLaVida; // = 43 + +// Mencionabamos anteriormente que __proto__ no está estandarizado, y que no +// existe una forma estándar de accesar al prototipo de un objeto. De todas formas. +// hay dos formas de crear un nuevo objeto con un prototipo dado. + +// El primer método es Object.create, el cual es una adición reciente a JavaScript, +// y por lo tanto, no disponible para todas las implementaciones aún. +var miObjeto = Object.create(miPrototipo); +miObjeto.sentidoDeLaVida; // = 43 + +// El segundo método, el cual trabaja en todos lados, tiene que ver con los +// constructores. Los constructores tienen una propiedad llamada prototype. +// Este NO ES el prototipo de la función constructor; es el prototipo que +// se le da a los nuevos objetos cuando son creados con la palabra clave +// new. + +MiConstructor.prototype = { + miNumero: 5, + getMiNumero: function(){ + return this.miNumero; + } +}; +var miNuevoObjeto2 = new MiConstructor(); +miNuevoObjeto2.getMiNumero(); // = 5 +miNuevoObjeto2.miNumero = 6 +miNuevoObjeto2.getMiNumero(); // = 6 + +// Los tipos que vienen por defecto en JavaScript (como Strings y números) +// también tienen constructores que crean objetos equivalentes. +var miNumero = 12; +var miNumeroObjeto = new Number(12); +miNumero == miNumeroObjeto; // = true + +// No son exactamente iguales. +typeof miNumero; // = 'number' +typeof miNumeroObjeto; // = 'object' +miNumero === miNumeroObjeyo; // = false +if (0){ + // Este código no se ejecutara porque 0 es false. +} + +// Aún así, los objetos que envuelven y los prototipos por defecto comparten +// un prototipo. así que puedes agregar funcionalidades a un string de la +// siguiente forma: +String.prototype.primerCaracter = function(){ + return this.charAt(0); +} +"abc".primerCaracter(); // = "a" + +// Este hecho se usa normalmente en "polyfilling", lo cual es implementar +// nuevas funciones a JavaScript en un JavaScript más viejo, así que pueda ser +// compatible con ambintes más viejos de JavaScript (por ejemplo, navegadores viejos). + +// Por ejemplo, mencionabamos que Object.create no está aún disponible en todas +// las implementaciones, pero podemos hacerlo con polyfill: +if (Object.create === undefined){ // esta validación sirve para no sobreescribir + Object.create = function(proto){ + // hace un constructor temporal con el prototipo correcto + var Constructor = function(){}; + Constructor.prototype = proto; + // y luego lo usamos para hacer un objeto con el prototipo + // correcto. + return new Constructor(); + } +} +``` + +## Fuentes y Referencias + +La [Red para Desarroladores de Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript) +proveé excelente documentación para JavaScript para navegadores. Además, está en formato de wiki, +por lo que mientras vayas aprendiendo podrás ayudar a los demás con tu experiencia. + +MDN [Una re-introducción a JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +cubre muchos de los conceptos que vimos aquí pero a mayor detalle. Esta guía cubre, más que nada, +el lenguaje JavaScript solo. Si quieres aprender a cómo usarlo en un ambiente web empieza aprendiendo +sobre el [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Aprende JavaScript con ejemplos y retos](http://www.learneroo.com/modules/64/nodes/350) es una +variante de esta guía pero con retos. + +[Jardín JavaScript](http://bonsaiden.github.io/JavaScript-Garden/) es una guía para todas las +funciones y características contra-intuitivas del lenguaje. + +[JavaScript: La guía definitiva](http://www.amazon.com/gp/product/0596805527/) es una guía clásica / libro de referencia. + +Aparte de las contribuciones directas para este artículo, algo del contenido se adaptó +del tutorial de Python por Louie Dinh en este sitio. y el [Tutorial JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) en la Red de Desarrolladores de Mozilla. diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown new file mode 100644 index 00000000..fff678eb --- /dev/null +++ b/es-es/json-es.html.markdown @@ -0,0 +1,59 @@ +--- +language: json +filename: learnjson-es.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Daniel Zendejas","https://github.com/DanielZendejas"] +lang: es-es +--- + +Siendo JSON un formato de intercambio de infomación tan sencillo, probablemente este será el Learn X in Y más sencillo jamás. + +JSON en su forma más pura no tiene comentarios, pero la mayoría de los parseadores aceptarán comentarios de C (//, /\* \*/). De todas formas, para el propóstio de esto todo será JSON 100% válido. Por suerte, habla por sí mismo. + +```json + +{ + "llave": "valor", + + "llaves": "siempre debe estar entre comillas (ya sean dobles o simples)", + "numeros": 0, + "strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".", + "soporta booleanos?": true, + "vacios": null, + + "numero grande": 1.2e+100, + + "objetos": { + "comentario": "La mayoria de tu estructura vendra de objetos.", + + "arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5], + + "otro objeto": { + "comentario": "Estas cosas pueden estar anidadas, muy util." + } + }, + + "tonteria": [ + { + "fuentes de potasio": ["bananas"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "estilo alternativo": { + "comentario": "Mira esto!" + , "posicion de la coma": "no importa - mientras este antes del valor, entonces sera valido" + , "otro comentario": "que lindo" + }, + + "eso fue rapido": "Y, estas listo. Ahora sabes todo lo que JSON tiene para ofrecer." +} +``` diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown new file mode 100644 index 00000000..e4181609 --- /dev/null +++ b/es-es/julia-es.html.markdown @@ -0,0 +1,940 @@ +--- +language: Julia +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Guillermo Garza", "http://github.com/ggarza"] + - ["Ismael Venegas Castelló", "https://github.com/Ismael-VC"] +filename: learnjulia-es.jl +lang: es-es +--- + + + +[Julia](http://julialanges.github.io) es un [lenguaje de programación](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n) [multiplataforma](http://es.wikipedia.org/wiki/Multiplataforma) y [multiparadigma](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_multiparadigma) de [tipado dinámico](http://es.wikipedia.org/wiki/Tipado_din%C3%A1mico), [alto nivel](http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel) y [alto desempeño](http://es.wikipedia.org/wiki/Computaci%C3%B3n_de_alto_rendimiento) para la computación [genérica](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_de_prop%C3%B3sito_general), [técnica y científica](http://es.wikipedia.org/wiki/Computaci%C3%B3n_cient%C3%ADfica), con una sintaxis que es familiar para los usuarios de otros entornos de computación técnica y científica. Provee de un [sofisticado compilador JIT](http://es.wikipedia.org/wiki/Compilaci%C3%B3n_en_tiempo_de_ejecuci%C3%B3n), [ejecución distribuida y paralela](http://docs.julialang.org/en/release-0.3/manual/parallel-computing), [precisión numérica](http://julia.readthedocs.org/en/latest/manual/integers-and-floating-point-numbers) y de una [extensa librería con funciones matemáticas](http://docs.julialang.org/en/release-0.3/stdlib). La librería estándar, escrita casi completamente en Julia, también integra las mejores y más maduras librerías de C y Fortran para el [álgebra lineal](http://docs.julialang.org/en/release-0.3/stdlib/linalg), [generación de números aleatorios](http://docs.julialang.org/en/release-0.3/stdlib/numbers/?highlight=random#random-numbers), [procesamiento de señales](http://docs.julialang.org/en/release-0.3/stdlib/math/?highlight=signal#signal-processing), y [procesamiento de cadenas](http://docs.julialang.org/en/release-0.3/stdlib/strings). Adicionalmente, la comunidad de [desarrolladores de Julia](https://github.com/JuliaLang/julia/graphs/contributors) contribuye un número de [paquetes externos](http://pkg.julialang.org) a través del gestor de paquetes integrado de Julia a un paso acelerado. [IJulia](https://github.com/JuliaLang/IJulia.jl), una colaboración entre las comunidades de [IPython](http://ipython.org) y Julia, provee de una poderosa interfaz gráfica basada en el [navegador para Julia](https://juliabox.org). + +En Julia los programas están organizados entorno al [despacho múltiple](http://docs.julialang.org/en/release-0.3/manual/methods/#man-methods); definiendo funciones y sobrecargándolas para diferentes combinaciones de tipos de argumentos, los cuales también pueden ser definidos por el usuario. + +### ¡Prueba Julia ahora mismo! + +* [TryJupyter](https://try.jupyter.org) +* [JuliaBox](https://juliabox.org) +* [SageMathCloud](https://cloud.sagemath.com) + +### Resumen de Características: + +* [Despacho múltiple](http://en.wikipedia.org/wiki/Multiple_dispatch): permite definir el comportamiento de las funciones a través de múltiples combinaciones de tipos de argumentos (**métodos**). +* Sistema de **tipado dinámico**: tipos para la documentación, la optimización y el despacho. +* [Buen desempeño](http://julialang.org/benchmarks), comparado al de lenguajes **estáticamente compilados** como C. +* [Gestor de paquetes](http://docs.julialang.org/en/release-0.3/stdlib/pkg) integrado. +* [Macros tipo Lisp](http://docs.julialang.org/en/release-0.3/manual/metaprogramming/#macros) y otras comodidades para la [meta programación](http://docs.julialang.org/en/release-0.3/manual/metaprogramming). +* Llamar funciones de otros lenguajes, mediante paquetes como: **Python** ([PyCall](https://github.com/stevengj/PyCall.jl)), [Mathematica](http://github.com/one-more-minute/Mathematica.jl), **Java** ([JavaCall](http://github.com/aviks/JavaCall.jl)), **R** ([Rif](http://github.com/lgautier/Rif.jl) y [RCall](http://github.com/JuliaStats/RCall.jl)) y **Matlab** ([MATLAB](http://github.com/JuliaLang/MATLAB.jl)). +* [Llamar funciones de C y Fortran](http://docs.julialang.org/en/release-0.3/manual/calling-c-and-fortran-code) **directamente**: sin necesidad de usar envoltorios u APIs especiales. +* Poderosas características de **línea de comandos** para [gestionar otros procesos](http://docs.julialang.org/en/release-0.3/manual/running-external-programs). +* Diseñado para la [computación paralela y distribuida](http://docs.julialang.org/en/release-0.3/manual/parallel-computing) **desde el principio**. +* [Corrutinas](http://en.wikipedia.org/wiki/Coroutine): hilos ligeros "**verdes**". +* Los [tipos definidos por el usuario](http://docs.julialang.org/en/release-0.3/manual/types) son tan **rápidos y compactos** como los tipos estándar integrados. +* [Generación automática de código](http://docs.julialang.org/en/release-0.3/stdlib/base/?highlight=%40code#internals) **eficiente y especializado** para diferentes tipos de argumentos. +* [Conversiones y promociones](http://docs.julialang.org/en/release-0.3/manual/conversion-and-promotion) para tipos numéricos y de otros tipos, **elegantes y extensibles**. +* Soporte eficiente para [Unicode](http://es.wikipedia.org/wiki/Unicode), incluyendo [UTF-8](http://es.wikipedia.org/wiki/UTF-8) pero sin limitarse solo a este. +* [Licencia MIT](https://github.com/JuliaLang/julia/blob/master/LICENSE.md): libre y de código abierto. + +Esto se basa en la versión `0.3.11`. + +```ruby +# Los comentarios de una línea comienzan con una almohadilla (o signo de gato). + +#= + Los comentarios multilínea pueden escribirse + usando '#=' antes de el texto y '=#' + después del texto. También se pueden anidar. +=# + + +############################################## +# 1. Tipos de datos primitivos y operadores. # +############################################## + +# Todo en Julia es una expresión (Expr). + +# Hay varios tipos básicos de números. +3 # => 3 # Int64 +3.2 # => 3.2 # Float64 +2 + 1im # => 2 + 1im # Complex{Int64} +2 // 3 # => 2//3 # Rational{Int64} + +# Todos los operadores infijos normales están disponibles. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 # dividir un Int por un Int siempre resulta + # en un Float +5 / 2 # => 2.5 +div(5, 2) # => 2 # para un resultado truncado, usa la función div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # exponente, no es XOR +12 % 10 # => 2 + +# Refuerza la precedencia con paréntesis. +(1 + 3) * 2 # => 8 + +# Operadores a nivel de bit. +~2 # => -3 # bitwise NOT +3 & 5 # => 1 # bitwise AND +2 | 4 # => 6 # bitwise OR +2 $ 4 # => 6 # bitwise XOR +2 >>> 1 # => 1 # desplazamiento lógico hacia la derecha +2 >> 1 # => 1 # desplazamiento aritmético hacia la derecha +2 << 1 # => 4 # desplazamiento lógico/aritmético hacia la izquierda + +# Se puede utilizar la función bits para ver la representación +# binaria de un número. +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" + +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# Los valores booleanos (Bool) son primitivos. +true # => true +false # => false + +# Operadores booleanos. +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true + +# ¡Las comparaciones pueden ser concatenadas! +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# Los literales de cadenas (String) se crean con la comilla doble: " +"Esto es una cadena." + +# Los literales de caracteres (Char) se crean con la comilla simple: ' +'a' + +# Una cadena puede ser indexada como una arreglo de caracteres. +"Esto es un string."[1] # => 'E' # Los índices en Julia comienzan en: 1 + +# Sin embargo, esto no va a funcionar bien para las cadenas UTF8 (UTF8String), +# Lo que se recomienda es la iteración (map, for, etc). + +# $ puede ser utilizado para la interpolación de cadenas, se puede poner +# cualquier expresión de Julia dentro los paréntesis. +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" + +# Otra forma para formatear cadenas es usando el macro printf. +@printf "%d es menor de %f\n" 4.5 5.3 # 5 es menor de 5.300000 + +# ¡Imprimir es muy fácil! +println("¡Hola Julia!") # ¡Hola Julia! + + +############################## +# 2. Variables y Colecciones # +############################## + +# No hay necesidad de declarar las variables antes de asignarlas. +una_variable = 5 # => 5 +una_variable # => 5 + +# Acceder a una variable no asignada previamente es una excepción. +try + otra_variable # ERROR: otra_variable not defined +catch e + println(e) # UndefVarError(:otra_variable) +end + +# Los nombres de variables comienzan con una letra o guion bajo: _. +# Después de eso, puedes utilizar letras, dígitos, guiones bajos y signos de +# exclamación. +otraVariable_123! = 6 # => 6 + +# También puedes utilizar caracteres Unicode. +☃ = 8 # => 8 + +# Estos son especialmente útiles para la notación matemática +# (multiplicación implicita). +2π # => 6.283185307179586 + +#= + Una nota sobre las convenciones de nomenclatura de Julia: + + * Los nombres de las variables aparecen en minúsculas, con separación de + palabra indicado por un guion bajo: + + otra_variable + + * Los nombres de los tipos comienzan con una letra mayúscula y separación de + palabras se muestra con CamelCase en vez de guión bajo: + + OtroTipo + + * Los nombres de las funciones y los macros están en minúsculas, sin + underscore: + + otromacro + + * Funciones que modifican sus entradas tienen nombres que terminan en: !. + Estas funciones a veces se les llaman funciones transformadoras o + funciones in situ: + + otra_funcion! +=# + +# Los arreglos (Array) almacenan una secuencia de valores indexados de entre 1 hasta n. +a = Int64[] # => 0-element Array{Int64,1} + +# Los literales de arregos unidimensionales se pueden escribir con valores +# separados por comas. +b = [4, 5, 6] +#= + => 3-element Array{Int64,1}: + 4 + 5 + 6 +=# +b[1] # => 4 +b[end] # => 6 + +# Los arreglos bidimensionales usan valores separados por espacios y filas +# separadas por punto y coma. +matrix = [1 2; 3 4] +#= + => 2x2 Array{Int64,2}: + 1 2 + 3 4 +=# + +# Añadir cosas al final de un arreglo con push! y append!. +push!(a, 1) # => [1] +push!(a, 2) # => [1,2] +push!(a, 4) # => [1,2,4] +push!(a, 3) # => [1,2,4,3] +append!(a, b) # => [1,2,4,3,4,5,6] + +# Eliminar del final con pop!. +pop!(b) # => 6 y b ahora es: [4,5] + +# Vamos a ponerlo de nuevo. +push!(b, 6) # b es ahora [4,5,6] de nuevo + +a[1] # => 1 # recuerda, los índices de Julia empiezan desde 1, no desde 0! + +# end es una abreviatura para el último índice. Se puede utilizar en cualquier +# expresión de indexación. +a[end] # => 6 + +# También hay shift! y unshift!. +shift!(a) # => 1 y a es ahora: [2,4,3,4,5,6] +unshift!(a, 7) # => [7,2,4,3,4,5,6] + +# Los nombres de funciones que terminan en exclamaciones indican que modifican +# su o sus argumentos de entrada. +arr = [5, 4, 6] # => 3-element Array{Int64,1}: [5,4,6] +sort(arr) # => [4,5,6] y arr es todavía: [5,4,6] +sort!(arr) # => [4,5,6] y arr es ahora: [4,5,6] + +# Buscando fuera de límites es un BoundsError. +try + a[0] # ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) # BoundsError() +end + +# Las excepciones y los errores dan la línea y el archivo de su procedencia, +# aunque provenga de la librería estándar. Si compilas Julia del código fuente, +# puedes buscar en el código para encontrar estos archivos. + +# Se puede inicializar un arreglo con un rango (Range). +a = [1:5] # => 5-element Array{Int64,1}: [1,2,3,4,5] + +# Puedes mirar en los rangos con la sintaxis de rebanada. +a[1:3] # => [1,2,3] +a[2:end] # => [2,3,4,5] + +# Eliminar elementos de un arreglo por índice con splice! +arr = [3, 4, 5] +splice!(arr, 2) # => 4 y arr es ahora: [3,5] + +# Concatenar arreglos con append! +b = [1, 2, 3] +append!(a, b) # a ahora es: [1,2,3,4,5,1,2,3] + +# Comprueba la existencia de un elemento en un arreglo con in. +in(1, a) # => true + +# Examina la longitud con length. +length(a) # => 8 + +# Las tuplas (Tuple) son inmutables. +tup = (1, 2, 3) # => (1,2,3) # una tupla tipo (Int64,Int64,Int64) +tup[1] # => 1 + +try: + tup[1] = 3 # ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) # MethodError(setindex!,(:tup,3,1)) +end + +# Muchas funciones de arreglos también trabajan en con las tuplas. +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +# Se pueden desempacar las tuplas en variables individuales. +a, b, c = (1, 2, 3) # => (1,2,3) # ahora a es 1, b es 2 y c es 3 + +# Los tuplas se crean, incluso si se omiten los paréntesis. +d, e, f = 4, 5, 6 # => (4,5,6) + +# Una tupla de un elemento es distinta del valor que contiene. +(1,) == 1 # => false +(1) == 1 # => true + +# Mira que fácil es cambiar dos valores! +e, d = d, e # => (5,4) # ahora d es 5 y e es 4 + +# Los diccionarios (Dict) son arreglos asociativos. +dicc_vacio = Dict() # => Dict{Any,Any} with 0 entries + +# Se puede crear un diccionario usando una literal. +dicc_lleno = ["uno" => 1, "dos" => 2, "tres" => 3] +#= + => Dict{ASCIIString,Int64} with 3 entries: + "tres" => 3 + "dos" => 2 + "uno" => 1 +=# + +# Busca valores con: []. +dicc_lleno["uno"] # => 1 + +# Obtén todas las claves con. +keys(dicc_lleno) +#= + => KeyIterator for a Dict{ASCIIString,Int64} with 3 entries. Keys: + "tres" + "dos" + "uno" +=# + +# Nota: los elementos del diccionario no están ordenados y no se guarda el orden +# en que se insertan. + +# Obtén todos los valores. +values(dicc_lleno) +#= + => ValueIterator for a Dict{ASCIIString,Int64} with 3 entries. Values: + 3 + 2 + 1 +=# + +# Nota: igual que el anterior en cuanto a ordenamiento de los elementos. + +# Comprueba si una clave existe en un diccionario con in y haskey. +in(("uno", 1), dicc_lleno) # => true +in(("tres", 3), dicc_lleno) # => false + +haskey(dicc_lleno, "uno") # => true +haskey(dicc_lleno, 1) # => false + +# Tratar de obtener un valor con una clave que no existe producirá un error. +try + # ERROR: key not found: cuatro in getindex at dict.jl:489 + dicc_lleno["cuatro"] +catch e + println(e) # KeyError("cuatro") +end + +# Utiliza el método get para evitar este error proporcionando un valor +# predeterminado: get(diccionario, clave, valor_predeterminado). +get(dicc_lleno, "uno", 4) # => 1 +get(dicc_lleno, "cuatro", 4) # => 4 + +# Usa conjuntos (Set) para representar colecciones de valores únicos, no +# ordenados. +conjunto_vacio = Set() # => Set{Any}({}) + +# Iniciar una conjunto de valores. +conjunto_lleno = Set(1, 2, 2, 3, 4) # => Set{Int64}({4,2,3,1}) + +# Añadir más valores a un conjunto. +push!(conjunto_lleno, 5) # => Set{Int64}({4,2,3,5,1}) +push!(conjunto_lleno, 5) # => Set{Int64}({4,2,3,5,1}) + +# Comprobar si los valores están en el conjunto. +in(2, conjunto_lleno) # => true +in(10, conjunto_lleno) # => false + +# Hay funciones de intersección, unión y diferencia de conjuntos. +otro_conjunto = Set(3, 4, 5, 6) # => Set{Int64}({6,4,5,3}) +intersect(conjunto_lleno, otro_conjunto) # => Set{Int64}({3,4,5}) +union(conjunto_lleno, otro_conjunto) # => Set{Int64}({1,2,3,4,5,6}) +setdiff(Set(1, 2, 3, 4), Set(2, 3, 5)) # => Set{Int64}({1,4}) + + +####################### +# 3. Control de Flujo # +####################### + +# Hagamos una variable. +una_variable = 5 + +# Aquí está la declaración de un if. La indentación no es significativa en +# Julia. +if una_variable > 10 + println("una_variable es completamente mayor que 10.") +elseif una_variable < 10 # esta condición elseif es opcional + println("una_variable es menor que 10.") +else # esto también es opcional + println("De echo una_variable es 10.") +end +# imprime: una_variable es menor que 10. + +# El bucle for itera sobre tipos iterables, ie. Range, Array, Set, +# Dict y String. +for animal in ["perro", "gato", "ratón"] + # Se puede usar $ para interpolar variables o expresiones en ls cadenas. + println("$animal es un mamífero.") +end +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# + +for a in ["perro" => "mamífero", "gato" => "mamífero", "ratón" => "mamífero"] + println("$(a[1]) es un $(a[2]).") +end +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# + +for (k,v) in ["perro"=>"mamífero", "gato"=>"mamífero", "ratón"=>"mamífero"] + println("$k es un $v.") +end +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# + +# El bucle while itera hasta que una condición se deje de cumplir. +x = 0 +while x < 4 + println(x) + x += 1 # versión corta de: x = x + 1 +end +#= +imprime: + 0 + 1 + 2 + 3 +=# + +# Maneja excepciones con un bloque try/catch. +try # intentar + error("Ooops!") +catch e + println("capturando: $e") # capturando: ErrorException("Ooops!") +end + + +################ +# 4. Funciones # +################ + +# Usa function para crear nuevas funciones. + +#= + function nombre(arglist) + cuerpo... + end +=# +function suma(x, y) + println("x es $x e y es $y") + + # las funciones devuelven el valor de su última expresión + x + y +end +# => suma (generic function with 1 method) + +suma(5, 6) # => 11 # después de imprimir: x es 5 e y es 6 + +# También puedes usar esta otra sintaxis para definir funciones! +resta(x, y) = x - y # => resta (generic function with 1 method) + +# Puedes definir funciones que toman un número variable de +# argumentos posicionales (el ... se llama un splat). +function varargs(args...) + # Usa la palabra clave return para regresar desde cualquier + # lugar de la función. + return args +end +# => varargs (generic function with 1 method) + +varargs(1, 2, 3) # => (1,2,3) +varargs([1, 2, 3]) # => ([1,2,3],) + +# Acabamos de utilizar el splat (...) en la definición de una función. También +# se puede utilizar al llamar a una función, donde se esparce un arreglo, tupla +# o en general una secuencia iterable en la tupla de argumentos. +varargs([1, 2, 3]...) # => (1,2,3) # igual que: varargs(1, 2, 3) + +x = (1, 2, 3) # => (1,2,3) +varargs(x) # => ((1,2,3),) +varargs(x...) # => (1,2,3) + +varargs("abc"...) # => ('a','b','c') + +# Puedes definir funciones con argumentos posicionales opcionales. +function defaults(a, b, x=5, y=6) + return "$a $b y $x $y" +end +# => defaults (generic function with 3 methods) + +defaults('h', 'g') # => "h g y 5 6" +defaults('h', 'g', 'j') # => "h g y j 6" +defaults('h', 'g', 'j', 'k') # => "h g y j k" + +try + defaults('h') # ERROR: `defaults` has no method matching defaults(::Char) + defaults() # ERROR: `defaults` has no method matching defaults() +catch e + println(e) # MethodError(defaults,('h',)) +end + +# Puedes definir funciones que tomen argumentos de palabras clave. +function args_clave(;k1=4, nombre2="hola") # nota el punto y coma: ; + return ["k1" => k1, "nombre2" => nombre2] +end +# => args_clave (generic function with 1 method) + +args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4] +args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"] +args_clave() # => ["nombre2"=>"hola","k1"=>4] + +# Puedes combinar todo tipo de argumentos en la misma función. +function todos_los_args(arg_posicional, arg_opcional=2; arg_clave="foo") + println("argumento posicional: $arg_posicional") + println(" argumento opcional: $arg_opcional") + println(" argumento clave: $arg_clave") +end +# => todos_los_args (generic function with 2 methods) + +# No se necesita punto y coma ; al llamar la función usando un argumento clave, +# esto solo es necesario en la definición de la función. +todos_los_args(1, 3, arg_clave=4) +#= + imprime: + argumento posicional: 1 + argumento opcional: 3 + argumento clave: 4 +=# + +# Julia tiene funciones de primera clase. +function crear_suma(x) + suma = function (y) # función anónima + return x + y + end + return suma +end +# => crear_suma (generic function with 1 method) + +# Esta es otra sintaxis (estilo cálculo lambda), para crear funciones anónimas. +(x -> x > 2)(3) # => true + +# Esta función es idéntica a la crear_suma implementación anterior. +crear_suma(x) = y -> x + y + +# También puedes nombrar la función interna, si quieres. +function crear_suma(x) + function suma(y) + x + y + end + suma +end +# => crear_suma (generic function with 1 method) + +suma_10 = crear_suma(10) # => suma (generic function with 1 method) +suma_10(3) # => 13 + +# Hay funciones integradas de orden superior. +map(suma_10, [1, 2, 3]) # => [11,12,13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6,7] + +# Se puede pasar un bloque a las funciones cuyo primer argumento posicional +# es otra función, como en map y filter. +map([1, 2, 3]) do arr + suma_10(arr) +end +#= + => 3-element Array{Int64,1}: + 11 + 12 + 13 +=# + +filter([3, 4, 5, 6, 7]) do arr + (x -> x > 5)(arr) +end +#= + => 2-element Array{Int64,1}: + 6 + 7 +=# + +# Podemos usar comprensiones de listas multidimensionales. +[suma_10(i) for i = [1, 2, 3]] # => [11, 12, 13] # 1D +[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +[i*j for i = [1:3], j in [1:3]] # 2D +#= + => 3x3 Array{Int64,2}: + 1 2 3 + 2 4 6 + 3 6 9 +=# + +[i*j/k for i = [1:3], j = [1:3], k in [1:3]] # 3D +#= + => 3x3x3 Array{Float64,3}: + [:, :, 1] = + 1.0 2.0 3.0 + 2.0 4.0 6.0 + 3.0 6.0 9.0 + + [:, :, 2] = + 0.5 1.0 1.5 + 1.0 2.0 3.0 + 1.5 3.0 4.5 + + [:, :, 3] = + 0.333333 0.666667 1.0 + 0.666667 1.33333 2.0 + 1.0 2.0 3.0 +=# + + +############ +# 5. Tipos # +############ + +# Cada valor tiene un tipo y las variables no tienen propios tipos. +# Se puede utilizar la función typeof para obtener el tipo de un valor. +typeof(5) # => Int64 # en un sistema de 64 bits, de lo contrario: Int32 + +# Los tipos son valores de primera clase, DataType es el tipo que representa a +# los tipos, incluyéndose a sí mismo. +typeof(Int64) # => DataType +typeof(DataType) # => DataType + +# Los tipos se usan para la documentación, para optimizaciones +# y el despacho múltiple. No están comprobados estáticamente. + +# Los usuarios pueden definir sus propios tipos. +# Son como registros o estructuras en otros idiomas. +# Un nuevo tipos se define utilizado la palabra clave type. + +# type Nombre +# atributo::UnTipo # las anotaciones de tipos son opcionales +# ... +# end +type Tigre + longitud_cola::Float64 + color_pelaje # sin una anotación de tipo, es lo mismo que `::Any` +end + +# Los argumentos del constructor por defecto son los atributos +# del tipo, en el orden en que están listados en la definición. +tigre = Tigre(3.5, "anaranjado") # => Tigre(3.5,"anaranjado") + +# El tipo funciona como método constructor para los valores de ese tipo. +sherekhan = typeof(tigre)(5.6, "fuego") # => Tigre(5.6,"fuego") + + +# Este estilo de tipos son llamados tipos concretos. +# Se pueden crear instancias de estos, pero no pueden tener subtipos. +# La otra clase de tipos son los tipos abstractos. + +# abstract Nombre +abstract Gato # sólo un nombre y un punto en la jerarquía de tipos + +# No se pueden crear instancias de los tipos abstractos, pero pueden tener +# subtipos. Por ejemplo, Number es un tipo abstracto. +subtypes(Number) +#= + => 2-element Array{Any,1}: + Complex{T<:Real} + Real +=# + +subtypes(Gato) # => 0-element Array{Any,1} + +# Cada tipo tiene un supertipo, utiliza la función súper para conseguirlo. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Integer +super(Integer) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Real +super(Any) # => Any + +# Todos estos tipos, a excepción de Int64, son abstractos. + +# <: es el operador de subtipos. +type Leon <: Gato # Leon es un subtipo de Gato + color_crin + rugido::String +end + +# Se pueden definir más constructores para un tipo. +# Sólo define una función del mismo nombre que el tipo y llama al constructor +# existente para obtener un valor del tipo correcto. + +# Este es un constructor externo porque está fuera de la definición del tipo. +Leon(rugido::String) = Leon("verde", rugido) + +type Pantera <: Gato # Pantera también es un a subtipo de Gato + color_ojos + + # Pantera sólo tendrá este constructor, y ningún constructor predeterminado. + Pantera() = new("verde") +end + +# Utilizar constructores internos, como se hace en Pantera, te da control sobre +# cómo se pueden crear valores de este tipo. Cuando sea posible, debes utilizar +# constructores externos en lugar de internos. + + +######################## +# 6. Despacho Múltiple # +######################## + +# En Julia, todas las funciones nombradas son funciones genéricas. +# Esto significa que se construyen a partir de muchos métodos más pequeños. +# Cada constructor de Leon es un método de la función genérica Leon. + +# Por ejemplo, vamos a hacer métodos para Leon, Pantera, y Tigre de una +# función genérica maullar: + +# acceso utilizando notación de puntos +maullar(animal::Leon) = animal.rugido +# => maullar (generic function with 1 method) +maullar(animal::Pantera) = "grrr" +# => maullar (generic function with 2 methods) +maullar(animal::Tigre) = "rawwwr" +# => maullar (generic function with 3 methods) + +# Se puede obtener una lista de métodos con la función methods. +methods(maullar) +#= + # 3 methods for generic function "maullar": + maullar(animal::Leon) at none:1 + maullar(animal::Pantera) at none:1 + maullar(animal::Tigre) at none:1 +=# + +# Prueba de la función maullar. +maullar(tigre) # => "rawwwr" +maullar(Leon("cafe", "ROAAR")) # => "ROAAR" +maullar(Pantera()) # => "grrr" + +# Revisar la jerarquía de tipos locales. +issubtype(Tigre, Gato) # => false # igual que: Tigre <: Gato +issubtype(Leon, Gato) # => true # igual que: Leon <: Gato +issubtype(Pantera, Gato) # => true + +# Definición de una función que acepta argumentos de tipo Gato. +mascota(gato::Gato) = println("El gato dice $(maullar(gato))") + +mascota(Leon("42")) # El gato dice 42 + +try + mascota(tigre) # ERROR: `mascota` has no method matching mascota(::Tigre) +catch e + println(e) # MethodError(mascota,(Tigre(3.5,"anaranjado"),)) +end + +# En los lenguajes orientados a objetos, el despacho simple es común. Esto +# significa que la implementación del método a llamar se selecciona en base +# al tipo del primer argumento. + +# En Julia, los tipos de todos los argumentos contribuyen a seleccionar método +# más específico. + +# Vamos a definir una función con más argumentos, para que podamos ver la +# diferencia +pelear(t::Tigre, c::Gato) = println("¡El tigre $(t.color_pelaje) gana!") +# => pelear (generic function with 1 method) + +pelear(tigre, Pantera()) # ¡El tigre anaranjado gana! +pelear(tigre, Leon("ROAR")) # ¡El tigre anaranjado gana! + +# Vamos a cambiar el comportamiento cuando el Gato sea específicamente un Leon. +pelear(t::Tigre, l::Leon) = println("El león con melena $(l.color_crin) gana.") +# => pelear (generic function with 2 methods) + +pelear(tigre, Pantera()) # ¡El tigre anaranjado gana! +pelear(tigre, Leon("ROAR")) # El león con melena verde gana. + +# No necesitamos un tigre para poder luchar. +pelear(l::Leon, c::Gato) = println("El gato victorioso dice $(maullar(c)).") +# => pelear (generic function with 3 methods) + +methods(pelear) +#= + # 3 methods for generic function "pelear": + pelear(t::Tigre,l::Leon) at none:2 + pelear(t::Tigre,c::Gato) at none:1 + pelear(l::Leon,c::Gato) at none:2 +=# + +pelear(Leon("balooga!"), Pantera()) # El gato victorioso dice grrr. +try + # ERROR: `pelear` has no method matching pelear(::Pantera, ::Leon) + pelear(Pantera(),Leon("RAWR")) +catch # no hacer nada con la excepción atrapada +end + +# Un metodo con el tipo Gato primero. +pelear(c::Gato,l::Leon) = println("El gato le gana al León") +#= + Warning: New definition + pelear(Gato,Leon) at none:1 + is ambiguous with: + pelear(Leon,Gato) at none:1. + To fix, define + pelear(Leon,Leon) + before the new definition. + pelear (generic function with 4 methods) +=# + +# Esta advertencia se debe a que no está claro que método de pelear +# será llamado en: +pelear(Leon("RAR"),Leon("cafe","rar")) # El gato victorioso dice rar. + +# El resultado puede ser diferente en otras versiones de Julia +pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate") + +pelear(Leon("GR"),Leon("cafe","rar")) # Los leones llegan a un empate + + +################################ +# 7. Un vistazo de bajo nivel. # +################################ + +# Se puede echar un vistazo al código IR de LLVM y al código +# ensamblador generado. +area_cuadrado(l) = l * l # => area_cuadrado (generic function with 1 method) + +area_cuadrado(5) # => 25 + +# ¿Qué sucede cuando damos area_cuadrada diferentes tipos de argumentos? +code_native(area_cuadrado, (Int32,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 # prólogo + push RBP + mov RBP, RSP + Source line: 1 + imul RDI, RDI # elevar l al cuadrado + mov RAX, RDI # almacenar el resultado en RAX + pop RBP # restaurar el puntero base anterior + ret # el resultado estará en RAX +=# + +code_native(area_cuadrado, (Float32,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + mulss XMM0, XMM0 # multiplicación escalar de presición simple (AVX) + pop RBP + ret +=# + +code_native(area_cuadrado, (Float64,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + mulsd XMM0, XMM0 # multiplicación escalar de presición doble (AVX) + pop RBP + ret +=# + +# Ten en cuenta que Julia usará instrucciones de punto flotante si el tipo de +# alguno de los argumentos es flotante. + +# Vamos a calcular el área de un círculo. +area_circulo(r) = π * r * r # area_circulo (generic function with 1 method) +area_circulo(5) # 78.53981633974483 + +code_native(area_circulo, (Int32,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + cvtsi2sd XMM1, EDI # cargar entero r de la memoria + movabs RAX, 4477117456 # cargar constante matemática π + movsd XMM0, QWORD PTR [RAX] + mulsd XMM0, XMM1 # π * r + mulsd XMM0, XMM1 # (π * r) * r + pop RBP + ret +=# + +code_native(area_circulo, (Float64,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + movabs RAX, 4477120336 + movsd XMM1, QWORD PTR [RAX] + Source line: 1 + mulsd XMM1, XMM0 + mulsd XMM1, XMM0 + movaps XMM0, XMM1 + pop RBP + ret +=# +``` + + + +## ¿Listo para más? + +Para más detalles, lee el [manual de Julia](http://docs.julialang.org/en/release-0.3). + +El mejor lugar para obtener ayuda con Julia, es en su amigable [lista de correos](https://groups.google.com/forum/#!forum/julia-users). diff --git a/es-es/livescript-es.html.markdown b/es-es/livescript-es.html.markdown new file mode 100644 index 00000000..103a3142 --- /dev/null +++ b/es-es/livescript-es.html.markdown @@ -0,0 +1,339 @@ +--- +language: LiveScript +filename: learnLivescript-es.ls +contributors: + - ["Christina Whyte", "http://github.com/kurisuwhyte/"] +translators: + - ["Daniel Zendejas", "http://github.com/DanielZendejas/"] +lang: es-es +--- + +LiveScript es un lenguaje funcional compilado sobre Javascript. Comparte +la mayoría de la semántica con este mismo lenguaje. Composición de funciones, +comparación de patrones y muchas otras cosas son las adiciones que hace +LiveScript. Está inspirado en lenguajes como Haskell, F# y Scala. + +Livescript es un bifurcación de [Coco][], que en sí mismo es una bifurcación +de [CoffeeScript][]. El lenguaje es estable, y una nueva versión está en +desarrollo activo para traer aún más funciones. + +[Coco]: http://satyr.github.io/coco/ +[CoffeeScript]: http://coffeescript.org/ + +La retroalimentación siempre es bienvenida, así que sientete libre de +contactarme en [@kurisuwhyte](https://twitter.com/kurisuwhyte) :) + +```coffeescript +# Justo como su primo CoffeeScript, LiveScript usa símbolos de gato para +# comentarios de una sola línea + +/* + Comentarios multi-línea son escritos con estilo de C. Usa este estilo si quieres + que los comentarios se preserven en el output de Javascript + */ +``` +```coffeescript +# En lo que a la sintaxis se refiere, LiveScript usa indentación para delimitar +# bloques en lugar de llaves {} y espacios para aplicar funciones, en lugar de +# paréntesis. + +######################################################################## +## 1. Valores básicos +######################################################################## + +# La carencia de valor se define con la palabra `void` en lugar de `undefined` +void # igual que `undefined` pero más seguro (no puede ser sobre escrito) + +# Ningún valor válido se representa con Null. +null + +# El valor básico más pequeño es de tipo lógico: +true +false + +# Y tiene múltiples alias que significan lo mismo: +on; off +yes; no + +# Luego vienen los números. Estos número con punto flotante tienen la misma +# precisión que los de JS: +10 +0.4 # Note que el `0` al inicio es requerido + +# Para fines de fácil lectura, puedes usar guiones bajos y sufijos en un +# número, y estos serán ignorados por el compilador. +12_344km + +# Los Strings son secuencias de caracteres inmutables, como en JS: +"Christina" # ¡Los apóstrofes están bien! +"""Strings + de muchas + líneas + están + bien + también.""" + +# A veces quieres codificar un palabra clave, la diagonal invertida sirve para esto: +\keyword # => 'keyword' + + +# Los arreglos son colecciones ordenadas de datos: +frutas = + * \manzana + * \naranja + * \pera + +# Una forma más concisa de representarlos son con corchetes: +frutas = [ \manzana, \naranja, \pera ] + +# Esta es una conveniente de crear listas de Strings, usando +# espacio en blanco para delimitar los items: +frutas = <[ manzana naranja pera ]> + +# Puedes recuperar un item usando su índice (empezando en 0): +frutas[0] # => "manzana" + +# Los objetos son colecciones de pares llave/valor sin ordenar, entre otras cosas, +# (detallaremos más al respecto en un momento): +persona = + nombre: "Christina" + gusta: + * "gatitos" + * "otras cosas" + +# Otra vez, puedes expresar el objeto con más consistencia con llaves {}: +persona = {nombre: "Christina", gusta: ["gatitos", "otras cosas"]} + +# Puedes conseguir un valor por medio de su llave: +persona.nombre # => "Christina" +persona["nombre"] # => "Christina" + + +# Las expresiones regulares tienen la misma sintaxis que en JavaScript: +expresion-regular = /\s$/ + +# A excepción de que puedes hacer expresiones de múltiples líneas +# (los comentarios y espacios se ignoran): +expresion-regular = // + function\s+(.+) # nombre + \s* \((.*)\) \s* # argumentos + { (.*) } # cuerpo + // + + +######################################################################## +## 2. Operaciones básicas +######################################################################## + +# Los operadores aritméticos son los mismos que en JavaScript: +1 + 2 # => 3 +2 - 1 # => 1 +2 * 3 # => 6 +4 / 2 # => 2 +3 % 2 # => 1 + + +# Las comparaciones son casi las mismas, excepto `==` que es igual +# a `===` en. El operador `==` de JS en LiveScript es `~=`, y `===` +# permite comparaciones entre objetos y arreglos, y también +# comparasiones más estrictas: +2 == 2 # => true +2 == "2" # => false +2 ~= "2" # => true +2 === "2" # => false + +[1,2,3] == [1,2,3] # => false +[1,2,3] === [1,2,3] # => true + ++0 == -0 # => true ++0 === -0 # => false + +# Otros operadores relacionales incluyen <, <=, > and >= + +# Los valores lógicos pueden ser combinados mediante los operadores +# lógicos `or`, `and` and `not`: +true and false # => false +false or true # => true +not false # => true + +# Las colecciones también tienen algunos operadores adicionales: +[1, 2] ++ [3, 4] # => [1, 2, 3, 4] +'a' in <[ a b c ]> # => true +'nombre' of { nombre: 'Chris' } # => true + + +######################################################################## +## 3. Funciones +######################################################################## + +# Como LiveScript es funcional, uno esperaría que las funciones recibirían +# un buen tratamiento. En LiveScript es más que aparente que las funciones +# son de primera clase: +suma = (primerElemento, segundoElemento) -> primerElemento + segundoElemento +add 1, 2 # => 3 + +# Las funciones que no reciben argumentos son llamadas rápidamente +dos = -> 2 +dos! + +# LiveScript, al igual que JS, aplica ámbitos (alcance) a sus variables y +# tiene cierres (closures) también. A diferencia de JavaScript, el operador +# `=` sirve como declaración y siempre declarará la variable en lado izquierdo. + +# El operador `:=` está disponible para *reusar* un nombre del ámbito del padre. + +# Puedes acceder a los argumentos de una función para conseguir +# los datos internos de una estructura de datos rápidamente: +cola = ([cabeza, ...resto]) -> resto +cola [1, 2, 3] # => [2, 3] + +# También puedes transformar argumentos usando operadores binarios o unarios. +# Argumentos por defecto también son posibles +foo = (a = 1, b = 2) -> a + b +foo! # => 3 + +# También puedes usarlo para clonar un argumento en particular para evitar efectos +# secundarios, por ejemplo: +copiar = (^^objetivo, fuente) -> + for k,v of fuente => objetivo[k] = v + objetivo +a = { a: 1 } +copiar a, { b: 2 } # => { a: 1, b: 2 } +a # => { a: 1 } + +# Una función puede ser abreviada usando una flecha larga en lugar de una corta: +suma = (primerElemento, segundoElemento) --> primerElemento + segundoElemento +sumaAbreviada = suma 1 +sumaAbreviada 2 # => 3 + +# Las funciones obtienen un argumento `it` implícito, incluso si no declaras +# ningún argument +identidad = -> it +identidad 1 # => 1 + +# Los operadores no son funciones en LiveScript. ¡Pero se pueden convertir fácilmente +# en una! Presentamos el seccionamiento de operadores: +dividir-entre-2 = (/ 2) +[2, 4, 8, 16].map(dividir-entre-2) .reduce (+) + +# LiveScript vive de otras cosas aparte de las funciones. Como en cualquier lenguaje +# funcional obtienes medios para componer (juntar) funciones: +doble-menos-uno = (- 1) . (* 2) + +# A parte de la clásica fórmula matemática `f . g`, también cuentas co los operadores +# `>>` y `<<`, que describen el flujo de los valores dentro de las funciones: +double-minus-one = (* 2) >> (- 1) +double-minus-one = (- 1) << (* 2) + +# Hablando del flujo de los valores, LiveScript también tiene los operadores `|>` y `<|` +# que aplican un valor a una función: +map = (f, xs) --> xs.map f +[1 2 3] |> map (* 2) # => [2 4 6] + +# También puedes escoger dónde quieres que el valor se posicione, sólo márcalo con un +# guíon bajo: +reducir = (f, xs, initial) --> xs.reducir f, initial +[1 2 3] |> reducir (+), _, 0 # => 6 + +# El guíon bajo también se usa para apartar lugares para tus argumentos, por ejemplo: +division = (dividendo,divisor) -> dividendo / divisor +dividir-entre-2 = division _, 2 +dividir-entre-2 4 # => 2 + +# Por último, LiveScript tiene back-calls (útiles mecanismos para hacer +# callbacks.). A pesar de esto deberías intentar formas más funcionales de hacerlo, +# como Promises: +leerArchivo = (nombre, f) -> f name +a <- leerArchivo 'foo' +b <- leerArchivo 'bar' +console.log a + b + +# Igual a: +leerArchivo 'foo', (a) -> leerArchivo 'bar', (b) -> console.log a + b + + +######################################################################## +## 4. Patrones, guardias y control de flujo +######################################################################## + +# Puedes bifurcar cálculos con la expresión `if...else`: +x = if n > 0 then \positive else \negative + +# En lugar de `then`, puedes usar `=>` +x = if n > 0 => \positivo + else \negativo + +# A pesar de esto, a las condiciones complejas es mejor expresarlas con el `switch`: +y = {} +x = switch + | (typeof y) is \number => \numero + | (typeof y) is \string => \string + | 'length' of y => \arreglo + | otherwise => \objeto # `otherwise` y `_` son lo mismo. + +# Los cuerpos de las funciones, declaraciones y asignaciones tienen un `switch` por defecto, +# así que no necesitas escribirlo nuevamente: + +take = (n, [x, ...xs]) --> + | n == 0 => [] + | _ => [x] ++ take (n - 1), xs + + +######################################################################## +## 5. Comprehensions (Auxiliares) +######################################################################## + +# Mientras que los auxiliares funcionales (para lidiar con listas y objetos) +# están en la librería estándar de JavaScript (y complementada con prelude-ls, +# que es una "librería estándar" de LiveScipt) los "comprehensions" (Auxiliares) +# usualemente te permiten hacer lo mismo pero más rápido y con una sintaxis más +# comprehensible (de ahí su nombre en inglés): +unoAVeinte = [1 to 20] +pares = [x for x in oneToTwenty when x % 2 == 0] + +# `when` y `unless` pueden ser usados como filtros en el auxiliar. + +# Los auxiliares para objetos funcionan de la misma forma, excepto que regresa un +# objeto en lugar de un arreglo: +copiar = { [k, v] for k, v of source } + + +######################################################################## +## 4. PROGRAMACIÓN ORIENTADA A OBJETOS +######################################################################## + +# Mientras que LiveScript es un lenguaje funcional en la mayoría de los +# aspectos, también brinda ayudas para la programación orientada a objetos. +# Algunas de estas ayudas son la sintaxis para las clases y un poco de "azucar" +# para las clases heredada de CoffeeScript: +class Animal + (@nombre, tipo) -> + @tipo = tipo + action: (accion) -> "*#{@nombre} (un #{@tipo}) #{accion}*" + +class Gato extends Animal + (@nombre) -> super @nombre, 'gato' + ronronear: -> @action 'ronronea' + +gatito = new Gato 'Mei' +gatito.purr! # => "*Mei (un gato) ronronea*" + +# A parte del clásico patrón de herencia simple, también puedes proveer +# cuantas mezclas quieras para una clase. Las mezclas sólo son objetos: +Abrazable = + abrazar: -> @action 'es abrazado' + +class GatoAbrazable extends Gato implements Abrazable + +gatito = new GatoAbrazable 'Ronroneo' +gatito.abrazar! # => "*Mei (un gato) es abrazado*" +``` + +## Más recursos + +Existe mucho más sobre LiveScript, pero esto debe bastar para que empieces. +El [sitio oficial](http://livescript.net/) tiene mucha información sobre el +lenguaje, y un compilador en linea para que pruebes cosas inmediatamente. + +También querras probar un poco de [prelude.ls](http://gkz.github.io/prelude-ls/), +y probar el canal `#livescript` en la red Freenode. diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown new file mode 100644 index 00000000..d90e3eb5 --- /dev/null +++ b/es-es/markdown-es.html.markdown @@ -0,0 +1,252 @@ +--- +language: markdown +filename: markdown-es.md +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +lang: es-es +--- + +Markdown fue creado por John Gruber en 2004. Su propósito es ser una sintaxis fácil de leer y escribir que se convierta +fácilmente a HTML (y, actualmente, otros formatos también). + +¡Denme todo la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests! + + +```markdown +<!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown +válido, eso significa que podemos usar elementos HTML en Markdown como, por +ejemplo, el comentario y no serán afectados por un parseador Markdown. Aún +así si creas un elemento HTML en tu archivo Markdown no podrás usar sintaxis +Markdown dentro de él. --> + +<!-- La implementación de Markdown cambia de acuerdo al parseador. Esta +guía servirá para clarificar cuales características son universales y +cuales son específicas de cada parseador--> + +<!-- Headers --> +<!-- Puedes crear headers HTML fácilmente precediendo al texto con una serie +de símbolos de números (#)--> + +# Esto es un <h1> +## Esto es un <h2> +### Esto es un <h3> +#### Esto es un <h4> +##### Esto es un <h5> +###### Esto es un <h6> + +<!-- Markdown también nos proveé con dos alternativas para indicar h1 y h2 --> +Esto es un h1 +============= + +Esto es un h2 +------------- + +<!-- Estilos para texto plano --> +<!-- El texto puede ser fácilmente estilizaedo con italicas, negritas o tachado +usando markdown --> + +*Este texto está en itálicas.* +_Al igual que este texto._ + +**Este texto está en negritas.** +__Al igual que este texto.__ + +***Este texto tiene ambos estilos.*** +**_Al igual que este!_** +*__¡Y este!__* + +<!-- En Github Flavored Markdown, el cual es usado para mostrar archivos +Markdown en Github, también tenemos: --> + +~~Este texto está tachado.~~ + +<!-- Los párrafos son una o múltuples líneas de texto adyacentes separadas por +una o múltiples líneas en blanco--> + +Este es un párrafo. Estoy escribiendo un párrafo, ¿No es divertido? + +Ahora estoy en el párrafo dos. +¡Sigo en el párrafo dos! + +¡Estoy en el párrafo tres! + +<!-- Si en algún momento quieres insertar un break HTML <br />, puedes terminar +un párrafo con dos o más espacios y luego empieza un párrafo nuevo--> + +Termino con dos espacios (selecciona esta línea completa para que los veas). + +¡Hay un <br /> arriba de mí! + +<!-- Las citas de bloque son fáciles y se pueden hacer con el caracter >. --> + +> Esta es una cita de bloque. Puedes +> envolver tus líneas manualmente y poner un `>` antes de cada línea o puedes dejar que tus líneas sean muy largas y que se envuelvan solas. +> No hay diferencia, siempre y cuando empiecen con `>`. + +> ¿También puedes usar más de un nivel +>> de indentación? +> Esto es muy útil ¿No? + +<!-- Listas --> +<!-- Las listas desordenadas se hacen usando asteriscos, símbolos de más, + o guiones --> + +* Item +* Item +* Otro item + +o + ++ Item ++ Item ++ Un item más + +o + +- Item +- Item +- El último item + +<!-- Las listas ordenadas se logran con un número seguido de un punto --> + +1. Item uno +2. Item dos +3. Item tres + +<!-- Aunque Markdown mostrará los items correctamente en orden, esto no +es una buena idea --> + +1. Item uno +1. Item dos +1. Item tres +<!-- (Esto muestra lo mismo que el ejemplo de arriba) --> + +<!-- También puedes usar sub-listas --> + +1. Item uno +2. Item dos +3. Item tres + * Sub-item + * Sub-item +4. Item cuatro + +<!-- Bloques de código --> +<!-- Puedes indicar un bloque de código (usan los elementos <code>) indentando +una línea con cuatro espacios o un tab--> + + Esto es código + Esto también + +<!-- También puedes insertar dos tabs (o cuatro espacios adicionales) +para indentar dentro del código --> + + my_array.each do |item| + puts item + end + +<!-- Código dentro de la línea puede ser escrito usando la comilla ` --> + +¡John no sabía lo que la función `go_to()` hacía! + +<!-- Con Github Flavored Markdown, puedes usar una sintaxis especial para código --> + +\`\`\`ruby <!-- quita esas comillas cuando lo hagas, deja sólo ```ruby ! --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- aquí también, sin comillas, sólo ``` --> + +<!-- El texto de arriba no necesita indentación, aparte Github usará +resaltará la sintaxis del lenguaje que especifiques después de ``` --> + +<!-- Regla horizontal (<hr />) --> +<!-- Las reglas horizontales se agregan fácilmente con tres o más asteriscos o guiones, +con o sin espacios. --> + +*** +--- +- - - +**************** + +<!-- Ligas --> +<!-- Una de las mejores cosas de Markdown es la facilidad para hacer ligas. Pon +el texto a mostrar en corchetes [] seguidos por la URL en paréntesis () --> + +[¡Haz click!](http://test.com/) + +<!-- También puedes agregar el titulo de la liga usando comillas dentro de los paréntesis --> + +[¡Haz click!](http://test.com/ "Liga al test.com") + +<!-- También funcionan las rutas relativas. --> + +[Ir a la música](/music/). + +<!-- Markdown también soporta ligas con estilo de referencia --> + +¡[Has click a esta liga][liga1] para más información! +[También mira esta liag][foobar] si quieres. + + + + +<!-- El título también puede estar en comillas simples o dentro de paréntesis, +también se pueden omitir completamente. Las referencias pueden estar en cualquier +lugar en tu documento y los IDs de referencia pueden ser lo que sea mientras sean únicos. --> + +<!-- También hay "nombramiento implicito" el cual te permite usar el texto de la liga como id --> + +[Esta][] es una liga. + + + +<!-- Pero no se usa comúnmente. --> + +<!-- Imagenes --> +<!-- Las imagenes se hacen de la misma forma que las ligas pero con un símbolo de exclamaciónal frente! --> + + + +<!-- Y el estilo de referencia funciona como se espera --> + +![Esta es una etiqueta.][myimage] + + + +<!-- Misceláneos --> +<!-- Auto-ligas --> + +<http://testwebsite.com/> equivale a +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Auto-ligas para correos electrónicos --> + +<foo@bar.com> + +<!-- Escapando caracteres --> + +Quiero escribir *este texto rodeado por asteriscos* pero no quiero que esté en itálicas, +así que hago esto: \*Este texto está rodeado de asteriscos\*. + +<!-- Tablas --> +<!-- Las tablas sólo están disponibles en Github Flavored Markdown y son un poco pesadas, +pero si de verdad las quieres: --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| Izquierda | Centrado | Derecha | +| blah | blah | blah | + +<!-- o, para los mismos resultados --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ugh esto es feo | has que | pare. + +<!-- ¡El fin! --> + +``` + +Para más información, mira el post oficial de John Gruber's [aquí](http://daringfireball.net/projects/markdown/syntax) y la gran referencia de Adam Pritchard's [aquí](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown new file mode 100644 index 00000000..644182ff --- /dev/null +++ b/es-es/perl-es.html.markdown @@ -0,0 +1,156 @@ +--- +name: perl +category: language +language: perl +filename: learnperl-es.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] +translators: + - ["Francisco Gomez", "http://github.com/frncscgmz"] + - ["Joaquín Ferrero", "http://github.com/joaquinferrero"] +lang: es-es +--- + +Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo. + +Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala. + +```perl +# Comentarios de una sola línea con un carácter hash + +#### Tipos de variables en Perl + +# Las variables comienzan con el símbolo $ +# Un nombre de variable válido empieza con una letra o un guión bajo, +# seguido por cualquier número de letras, números o guiones bajos + +### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes + +## Escalares +# Un escalar representa un solo valor: +my $animal = "camello"; +my $respuesta = 42; + +# Los valores escalares pueden ser cadenas de caracteres, números enteros o +# de punto flotante; Perl automáticamente los convertirá como sea requerido + +## Arreglos +# Un arreglo representa una lista de valores: +my @animales = ("camello","llama","buho"}; +my @numeros = (23, 42, 69); +my @mixto = ("camello", 42, 1.23); + +## Hashes +# Un hash representa un conjunto de pares llave/valor: +my %color_fruta = ("manzana","rojo","banana","amarillo"); + +# Puede usar un espacio en blanco y el operador "=>" para asignarlos más fácilmente +my %color_fruta = ( + manzana => "rojo", + banana => "amarillo", +); + +# Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata) + +# Los tipos de datos más complejos se pueden construir utilizando +# referencias, las cuales le permiten construir listas y hashes dentro +# de listas y hashes + +#### Estructuras condicionales y de ciclos + +# Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes +if ( $var ) { + ...; +} elsif ( $var eq 'bar' ) { + ...; +} else { + ...; +} + +unless ( condicion ) { + ...; +} + +# Esto se ofrece como una versión más fácil de leer que "if (!condición)" + +# La postcondición al modo Perl: +print "Yow!" if $zippy; +print "No tenemos bananas" unless $bananas; + +# while +while ( condicion ) { + ...; +} + +# for y foreach +for ($i = 0; $i <= $max; $i++) { + ...; +} + +for $i (0 .. $max) { + ...; +} + +foreach (@array) { + print "Este elemento es $_\n"; +} + + +#### Expresiones regulares + +# El soporte de expresiones regulares en Perl es muy amplio y profundo, y +# está sujeto a una extensa documentación en perlrequick, perlretut, entre otros. +# Sin embargo, resumiendo: + +# Coincidencia simple +if (/foo/) { ... } # verdadero si $_ contiene "foo" +if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo" + +# Substitución simple +$a =~ s/foo/bar/; # remplaza "foo" con "bar" en $a +$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en $a + + +#### Archivos y E/S + +# Puede abrir un archivo para obtener datos o escribirlos utilizando la +# función "open()" + +open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!"; +open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!"; +open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!"; + +# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>". +# En contexto escalar, leer una sola línea desde el gestor de archivo, y +# en contexto de lista, leer el archivo completo en donde asigna +# cada línea a un elemento de la lista + +my $linea = <$entrada>; +my @lineas = <$entrada>; + +#### Escribiendo subrutinas + +# Escribir subrutinas es fácil: +sub logger { + my $mensajelog = shift; + open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!"; + print $archivolog $mensajelog; +} + +# Ahora podemos utilizar la subrutina al igual que cualquier otra función incorporada: +logger("Tenemos una subrutina logger!"); + +``` + +#### Utilizando módulos Perl + +Los módulos en Perl proveen de una gama de funciones que le pueden ayudar a evitar reinventar la rueda. Éstas se pueden descargar desde CPAN ( http://www.cpan.org/ ). Algunos de los módulos más populares ya están incluidos con la misma distribución de Perl. + +perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos de CPAN que puede usar. + +#### Material de Lectura + + - [perl-tutorial](http://perl-tutorial.org/) + - [Learn Perl](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - y en su propio perl: `perldoc perlintro` diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown new file mode 100644 index 00000000..4930eebc --- /dev/null +++ b/es-es/python-es.html.markdown @@ -0,0 +1,562 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Camilo Garrido", "http://www.twitter.com/hirohope"] + - ["Fabio Souto", "http://fabiosouto.me"] +lang: es-es +filename: learnpython-es.py +--- + +Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno +de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica. +Es básicamente pseudocódigo ejecutable. + +¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google] + +Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3! + +```python +# Comentarios de una línea comienzan con una almohadilla (o signo gato) +""" Strings multilinea pueden escribirse + usando tres "'s, y comunmente son usados + como comentarios. +""" + +#################################################### +## 1. Tipos de datos primitivos y operadores. +#################################################### + +# Tienes números +3 #=> 3 + +# Evidentemente puedes realizar operaciones matemáticas +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# La división es un poco complicada. Es división entera y toma la parte entera +# de los resultados automáticamente. +5 / 2 #=> 2 + +# Para arreglar la división necesitamos aprender sobre 'floats' +# (números de coma flotante). +2.0 # Esto es un 'float' +11.0 / 4.0 #=> 2.75 ahhh...mucho mejor + +# Resultado de la división de enteros truncada para positivos y negativos +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # funciona con números en coma flotante +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# El operador módulo devuelve el resto de una división entre enteros +7 % 3 # => 1 + +# Exponenciación (x elevado a y) +2**4 # => 16 + +# Refuerza la precedencia con paréntesis +(1 + 3) * 2 #=> 8 + +# Operadores booleanos +# Nota: "and" y "or" son sensibles a mayúsculas +True and False #=> False +False or True #=> True + +# Podemos usar operadores booleanos con números enteros +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Niega con 'not' +not True #=> False +not False #=> True + +# Igualdad es == +1 == 1 #=> True +2 == 1 #=> False + +# Desigualdad es != +1 != 1 #=> False +2 != 1 #=> True + +# Más comparaciones +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# ¡Las comparaciones pueden ser concatenadas! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Strings se crean con " o ' +"Esto es un string." +'Esto también es un string' + +# ¡Strings también pueden ser sumados! +"Hola " + "mundo!" #=> "Hola mundo!" + +# Un string puede ser tratado como una lista de caracteres +"Esto es un string"[0] #=> 'E' + +# % pueden ser usados para formatear strings, como esto: +"%s pueden ser %s" % ("strings", "interpolados") + +# Una forma más reciente de formatear strings es el método 'format'. +# Este método es la forma preferida +"{0} pueden ser {1}".format("strings", "formateados") +# Puedes usar palabras clave si no quieres contar. +"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") + +# None es un objeto +None #=> None + +# No uses el símbolo de igualdad `==` para comparar objetos con None +# Usa `is` en lugar de +"etc" is None #=> False +None is None #=> True + +# El operador 'is' prueba la identidad del objeto. Esto no es +# muy útil cuando se trata de datos primitivos, pero es +# muy útil cuando se trata de objetos. + +# None, 0, y strings/listas vacíos(as) todas se evalúan como False. +# Todos los otros valores son True +bool(0) #=> False +bool("") #=> False + + +#################################################### +## 2. Variables y Colecciones +#################################################### + +# Imprimir es muy fácil +print "Soy Python. ¡Encantado de conocerte!" + + +# No hay necesidad de declarar las variables antes de asignarlas. +una_variable = 5 # La convención es usar guiones_bajos_con_minúsculas +una_variable #=> 5 + +# Acceder a variables no asignadas previamente es una excepción. +# Ve Control de Flujo para aprender más sobre el manejo de excepciones. +otra_variable # Levanta un error de nombre + +# 'if' puede ser usado como una expresión +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Las listas almacenan secuencias +lista = [] +# Puedes empezar con una lista prellenada +otra_lista = [4, 5, 6] + +# Añadir cosas al final de una lista con 'append' +lista.append(1) # lista ahora es [1] +lista.append(2) # lista ahora es [1, 2] +lista.append(4) # lista ahora es [1, 2, 4] +lista.append(3) # lista ahora es [1, 2, 4, 3] +# Remueve del final de la lista con 'pop' +lista.pop() #=> 3 y lista ahora es [1, 2, 4] +# Pongámoslo de vuelta +lista.append(3) # Nuevamente lista ahora es [1, 2, 4, 3]. + +# Accede a una lista como lo harías con cualquier arreglo +lista[0] #=> 1 +# Mira el último elemento +lista[-1] #=> 3 + +# Mirar fuera de los límites es un error 'IndexError' +lista[4] # Levanta la excepción IndexError + +# Puedes mirar por rango con la sintáxis de trozo. +# (Es un rango cerrado/abierto para ustedes los matemáticos.) +lista[1:3] #=> [2, 4] +# Omite el inicio +lista[2:] #=> [4, 3] +# Omite el final +lista[:3] #=> [1, 2, 4] + +# Remueve elementos arbitrarios de una lista con 'del' +del lista[2] # lista ahora es [1, 2, 3] + +# Puedes sumar listas +lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan + +# Concatenar listas con 'extend' +lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6] + +# Chequea la existencia en una lista con +1 in lista #=> True + +# Examina el tamaño de una lista con 'len' +len(lista) #=> 6 + + +# Las tuplas son como las listas, pero son inmutables. +tupla = (1, 2, 3) +tupla[0] #=> 1 +tupla[0] = 3 # Levanta un error TypeError + +# También puedes hacer todas esas cosas que haces con listas +len(tupla) #=> 3 +tupla + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tupla[:2] #=> (1, 2) +2 in tupla #=> True + +# Puedes desempacar tuplas (o listas) en variables +a, b, c = (1, 2, 3) # a ahora es 1, b ahora es 2 y c ahora es 3 +# Tuplas son creadas por defecto si omites los paréntesis +d, e, f = 4, 5, 6 +# Ahora mira que fácil es intercambiar dos valores +e, d = d, e # d ahora es 5 y e ahora es 4 + + +# Diccionarios almacenan mapeos +dicc_vacio = {} +# Aquí está un diccionario prellenado +dicc_lleno = {"uno": 1, "dos": 2, "tres": 3} + +# Busca valores con [] +dicc_lleno["uno"] #=> 1 + +# Obtén todas las llaves como una lista +dicc_lleno.keys() #=> ["tres", "dos", "uno"] +# Nota - El orden de las llaves del diccionario no está garantizada. +# Tus resultados podrían no ser los mismos del ejemplo. + +# Obtén todos los valores como una lista +dicc_lleno.values() #=> [3, 2, 1] +# Nota - Lo mismo que con las llaves, no se garantiza el orden. + +# Chequea la existencia de una llave en el diccionario con 'in' +"uno" in dicc_lleno #=> True +1 in dicc_lleno #=> False + +# Buscar una llave inexistente deriva en KeyError +dicc_lleno["cuatro"] # KeyError + +# Usa el método 'get' para evitar la excepción KeyError +dicc_lleno.get("uno") #=> 1 +dicc_lleno.get("cuatro") #=> None +# El método 'get' soporta un argumento por defecto cuando el valor no existe. +dicc_lleno.get("uno", 4) #=> 1 +dicc_lleno.get("cuatro", 4) #=> 4 + +# El método 'setdefault' es una manera segura de añadir nuevos pares +# llave-valor en un diccionario +dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5 +dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5 + + +# Sets (conjuntos) almacenan ... bueno, conjuntos +conjunto_vacio = set() +# Inicializar un conjunto con montón de valores +un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4]) + +# Desde Python 2.7, {} puede ser usado para declarar un conjunto +conjunto_lleno = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Añade más valores a un conjunto +conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5} + +# Haz intersección de conjuntos con & +otro_conjunto = {3, 4, 5, 6} +conjunto_lleno & otro_conjunto #=> {3, 4, 5} + +# Haz unión de conjuntos con | +conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6} + +# Haz diferencia de conjuntos con - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Chequea la existencia en un conjunto con 'in' +2 in conjunto_lleno #=> True +10 in conjunto_lleno #=> False + + +#################################################### +## 3. Control de Flujo +#################################################### + +# Hagamos sólo una variable +una_variable = 5 + +# Aquí está una declaración de un 'if'. ¡La indentación es importante en Python! +# imprime "una_variable es menor que 10" +if una_variable > 10: + print "una_variable es completamente mas grande que 10." +elif una_variable < 10: # Este condición 'elif' es opcional. + print "una_variable es mas chica que 10." +else: # Esto también es opcional. + print "una_variable es de hecho 10." + + +""" +For itera sobre listas +imprime: + perro es un mamifero + gato es un mamifero + raton es un mamifero +""" +for animal in ["perro", "gato", "raton"]: + # Puedes usar % para interpolar strings formateados + print "%s es un mamifero" % animal + +""" +`range(número)` retorna una lista de números +desde cero hasta el número dado +imprime: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +While itera hasta que una condición no se cumple. +imprime: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # versión corta de x = x + 1 + +# Maneja excepciones con un bloque try/except + +# Funciona desde Python 2.6 en adelante: +try: + # Usa raise para levantar un error + raise IndexError("Este es un error de indice") +except IndexError as e: + pass # Pass no hace nada. Usualmente harias alguna recuperacion aqui. + + +#################################################### +## 4. Funciones +#################################################### + +# Usa 'def' para crear nuevas funciones +def add(x, y): + print "x es %s y y es %s" % (x, y) + return x + y # Retorna valores con una la declaración return + +# Llamando funciones con parámetros +add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11 + +# Otra forma de llamar funciones es con argumentos de palabras claves +add(y=6, x=5) # Argumentos de palabra clave pueden ir en cualquier orden. + +# Puedes definir funciones que tomen un número variable de argumentos +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Puedes definir funciones que toman un número variable de argumentos +# de palabras claves +def keyword_args(**kwargs): + return kwargs + +# Llamémosla para ver que sucede +keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"} + +# Puedes hacer ambas a la vez si quieres +def todos_los_argumentos(*args, **kwargs): + print args + print kwargs +""" +todos_los_argumentos(1, 2, a=3, b=4) imprime: + (1, 2) + {"a": 3, "b": 4} +""" + +# ¡Cuando llames funciones, puedes hacer lo opuesto a varargs/kwargs! +# Usa * para expandir tuplas y usa ** para expandir argumentos de palabras claves. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +todos_los_argumentos(*args) # es equivalente a foo(1, 2, 3, 4) +todos_los_argumentos(**kwargs) # es equivalente a foo(a=3, b=4) +todos_los_argumentos(*args, **kwargs) # es equivalente a foo(1, 2, 3, 4, a=3, b=4) + +# Python tiene funciones de primera clase +def crear_suma(x): + def suma(y): + return x + y + return suma + +sumar_10 = crear_suma(10) +sumar_10(3) #=> 13 + +# También hay funciones anónimas +(lambda x: x > 2)(3) #=> True + +# Hay funciones integradas de orden superior +map(sumar_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Podemos usar listas por comprensión para mapeos y filtros agradables +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Clases +#################################################### + +# Heredamos de object para obtener una clase. +class Humano(object): + + # Un atributo de clase es compartido por todas las instancias de esta clase + especie = "H. sapiens" + + # Constructor básico, se llama al instanciar la clase. + def __init__(self, nombre): + # Asigna el argumento al atributo nombre de la instancia + self.nombre = nombre + + # Un método de instancia. Todos los metodos toman self como primer argumento + def decir(self, msg): + return "%s: %s" % (self.nombre, msg) + + # Un metodo de clase es compartido a través de todas las instancias + # Son llamados con la clase como primer argumento + @classmethod + def get_especie(cls): + return cls.especie + + # Un metodo estatico es llamado sin la clase o instancia como referencia + @staticmethod + def roncar(): + return "*roncar*" + + +# Instancia una clase +i = Humano(nombre="Ian") +print i.decir("hi") # imprime "Ian: hi" + +j = Humano("Joel") +print j.decir("hello") #imprime "Joel: hello" + +# Llama nuestro método de clase +i.get_especie() #=> "H. sapiens" + +# Cambia los atributos compartidos +Humano.especie = "H. neanderthalensis" +i.get_especie() #=> "H. neanderthalensis" +j.get_especie() #=> "H. neanderthalensis" + +# Llama al método estático +Humano.roncar() #=> "*roncar*" + + +#################################################### +## 6. Módulos +#################################################### + +# Puedes importar módulos +import math +print math.sqrt(16) #=> 4 + +# Puedes obtener funciones específicas desde un módulo +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Puedes importar todas las funciones de un módulo +# Precaución: Esto no es recomendable +from math import * + +# Puedes acortar los nombres de los módulos +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Los módulos de Python son sólo archivos ordinarios de Python. +# Puedes escribir tus propios módulos e importarlos. El nombre del módulo +# es el mismo del nombre del archivo. + +# Puedes encontrar que funciones y atributos definen un módulo. +import math +dir(math) + + +#################################################### +## 7. Avanzado +#################################################### + +# Los generadores permiten evaluación perezosa +def duplicar_numeros(iterable): + for i in iterable: + yield i + i + +# Un generador crea valores sobre la marcha +# En vez de generar y devolver todos los valores de una vez, crea un valor +# en cada iteración. En este ejemplo los valores mayores que 15 no serán +# procesados en duplicar_numeros. +# Nota: xrange es un generador que hace lo mismo que range. +# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio. +# xrange crea un generador, mientras que range crea toda la lista. +# Añadimos un guion bajo a los nombres de variable que coinciden con palabras +# reservadas de python. +xrange_ = xrange(1, 900000000) + +# duplica todos los números hasta que encuentra un resultado >= 30 +for i in duplicar_numeros(xrange_): + print i + if i >= 30: + break + +# Decoradores +# en este ejemplo pedir rodea a hablar +# Si por_favor es True se cambiará el mensaje. +from functools import wraps + + +def pedir(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, por_favor = target_function(*args, **kwargs) + if por_favor: + return "{} {}".format(msg, "¡Por favor! Soy pobre :(") + return msg + + return wrapper + + +@pedir +def hablar(por_favor=False): + msg = "¿Me puedes comprar una cerveza?" + return msg, por_favor + +print hablar() # ¿Me puedes comprar una cerveza? +print hablar(por_favor=True) # ¿Me puedes comprar una cerveza? ¡Por favor! Soy pobre :( +``` + +## ¿Listo para más? + +### Gratis y en línea + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +### Encuadernados + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown new file mode 100644 index 00000000..1c69481a --- /dev/null +++ b/es-es/python3-es.html.markdown @@ -0,0 +1,570 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] +translators: + - ["Camilo Garrido", "http://twitter.com/hirohope"] +lang: es-es +filename: learnpython3-es.py +--- + +Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno +de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica. +Es básicamente pseudocódigo ejecutable. + +¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google] + +Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3! + +```python + +# Comentarios de una línea comienzan con una almohadilla (o signo gato) + +""" Strings multilinea pueden escribirse + usando tres "'s, y comunmente son usados + como comentarios. +""" + +#################################################### +## 1. Tipos de datos primitivos y operadores. +#################################################### + +# Tienes números +3 #=> 3 + +# Matemática es lo que esperarías +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 + +# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante) +35 / 5 # => 7.0 + +# Cuando usas un float, los resultados son floats +3 * 2.0 # => 6.0 + +# Refuerza la precedencia con paréntesis +(1 + 3) * 2 # => 8 + + +# Valores 'boolean' (booleanos) son primitivos +True +False + +# Niega con 'not' +not True # => False +not False # => True + + +# Igualdad es == +1 == 1 # => True +2 == 1 # => False + +# Desigualdad es != +1 != 1 # => False +2 != 1 # => True + +# Más comparaciones +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# ¡Las comparaciones pueden ser concatenadas! +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# Strings se crean con " o ' +"Esto es un string." +'Esto también es un string' + +# ¡Strings también pueden ser sumados! +"Hola " + "mundo!" #=> "Hola mundo!" + +# Un string puede ser tratado como una lista de caracteres +"Esto es un string"[0] #=> 'E' + +# .format puede ser usaro para darle formato a los strings, así: +"{} pueden ser {}".format("strings", "interpolados") + +# Puedes repetir los argumentos de formateo para ahorrar tipeos. +"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela" +# Puedes usar palabras claves si no quieres contar. +"{nombre} quiere comer {comida}".format(nombre="Bob", food="lasaña") #=> "Bob quiere comer lasaña" + + +# None es un objeto +None # => None + +# No uses el símbolo de igualdad `==` para comparar objetos con None +# Usa `is` en lugar de +"etc" is None #=> False +None is None #=> True + +# None, 0, y strings/listas/diccionarios vacíos(as) todos se evalúan como False. +# Todos los otros valores son True +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. Variables y Colecciones +#################################################### + +# Python tiene una función para imprimir +print("Soy Python. Encantado de conocerte") + +# No hay necesidad de declarar las variables antes de asignarlas. +una_variable = 5 # La convención es usar guiones_bajos_con_minúsculas +una_variable #=> 5 + +# Acceder a variables no asignadas previamente es una excepción. +# Ve Control de Flujo para aprender más sobre el manejo de excepciones. +otra_variable # Levanta un error de nombre + +# Listas almacena secuencias +lista = [] +# Puedes empezar con una lista prellenada +otra_lista = [4, 5, 6] + +# Añadir cosas al final de una lista con 'append' +lista.append(1) #lista ahora es [1] +lista.append(2) #lista ahora es [1, 2] +lista.append(4) #lista ahora es [1, 2, 4] +lista.append(3) #lista ahora es [1, 2, 4, 3] +# Remueve del final de la lista con 'pop' +lista.pop() #=> 3 y lista ahora es [1, 2, 4] +# Pongámoslo de vuelta +lista.append(3) # Nuevamente lista ahora es [1, 2, 4, 3]. + +# Accede a una lista como lo harías con cualquier arreglo +lista[0] #=> 1 +# Mira el último elemento +lista[-1] #=> 3 + +# Mirar fuera de los límites es un error 'IndexError' +lista[4] # Levanta la excepción IndexError + +# Puedes mirar por rango con la sintáxis de trozo. +# (Es un rango cerrado/abierto para ustedes los matemáticos.) +lista[1:3] #=> [2, 4] +# Omite el inicio +lista[2:] #=> [4, 3] +# Omite el final +lista[:3] #=> [1, 2, 4] +# Selecciona cada dos elementos +lista[::2] # =>[1, 4] +# Invierte la lista +lista[::-1] # => [3, 4, 2, 1] +# Usa cualquier combinación de estos para crear trozos avanzados +# lista[inicio:final:pasos] + +# Remueve elementos arbitrarios de una lista con 'del' +del lista[2] # lista ahora es [1, 2, 3] + +# Puedes sumar listas +lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan + +# Concatenar listas con 'extend' +lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6] + +# Chequea la existencia en una lista con 'in' +1 in lista #=> True + +# Examina el largo de una lista con 'len' +len(lista) #=> 6 + + +# Tuplas son como listas pero son inmutables. +tupla = (1, 2, 3) +tupla[0] #=> 1 +tupla[0] = 3 # Levanta un error TypeError + +# También puedes hacer todas esas cosas que haces con listas +len(tupla) #=> 3 +tupla + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tupla[:2] #=> (1, 2) +2 in tupla #=> True + +# Puedes desempacar tuplas (o listas) en variables +a, b, c = (1, 2, 3) # a ahora es 1, b ahora es 2 y c ahora es 3 +# Tuplas son creadas por defecto si omites los paréntesis +d, e, f = 4, 5, 6 +# Ahora mira que fácil es intercambiar dos valores +e, d = d, e # d ahora es 5 y e ahora es 4 + + +# Diccionarios almacenan mapeos +dicc_vacio = {} +# Aquí está un diccionario prellenado +dicc_lleno = {"uno": 1, "dos": 2, "tres": 3} + +# Busca valores con [] +dicc_lleno["uno"] #=> 1 + +# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego. +list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"] +# Nota - El orden de las llaves del diccionario no está garantizada. +# Tus resultados podrían no ser los mismos del ejemplo. + +# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable. +list(dicc_lleno.values()) #=> [3, 2, 1] +# Nota - Lo mismo que con las llaves, no se garantiza el orden. + +# Chequea la existencia de una llave en el diccionario con 'in' +"uno" in dicc_lleno #=> True +1 in dicc_lleno #=> False + +# Buscar una llave inexistente deriva en KeyError +dicc_lleno["cuatro"] # KeyError + +# Usa el método 'get' para evitar la excepción KeyError +dicc_lleno.get("uno") #=> 1 +dicc_lleno.get("cuatro") #=> None +# El método 'get' soporta un argumento por defecto cuando el valor no existe. +dicc_lleno.get("uno", 4) #=> 1 +dicc_lleno.get("cuatro", 4) #=> 4 + +# El método 'setdefault' inserta en un diccionario solo si la llave no está presente +dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5 +dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5 + + +# Remueve llaves de un diccionario con 'del' +del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno + +# Sets (conjuntos) almacenan ... bueno, conjuntos +conjunto_vacio = set() +# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento. +un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4} + +# Añade más valores a un conjunto +conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5} + +# Haz intersección de conjuntos con & +otro_conjunto = {3, 4, 5, 6} +conjunto_lleno & otro_conjunto #=> {3, 4, 5} + +# Haz unión de conjuntos con | +conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6} + +# Haz diferencia de conjuntos con - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Chequea la existencia en un conjunto con 'in' +2 in conjunto_lleno #=> True +10 in conjunto_lleno #=> False + + +#################################################### +## 3. Control de Flujo +#################################################### + +# Let's just make a variable +some_var = 5 + +# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python! +# imprime "una_variable es menor que 10" +if una_variable > 10: + print("una_variable es completamente mas grande que 10.") +elif una_variable < 10: # Este condición 'elif' es opcional. + print("una_variable es mas chica que 10.") +else: # Esto también es opcional. + print("una_variable es de hecho 10.") + +""" +For itera sobre listas +imprime: + perro es un mamifero + gato es un mamifero + raton es un mamifero +""" +for animal in ["perro", "gato", "raton"]: + # Puedes usar % para interpolar strings formateados + print("{} es un mamifero".format(animal)) + +""" +`range(número)` retorna una lista de números +desde cero hasta el número dado +imprime: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +While itera hasta que una condición no se cumple. +imprime: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # versión corta de x = x + 1 + +# Maneja excepciones con un bloque try/except +try: + # Usa raise para levantar un error + raise IndexError("Este es un error de indice") +except IndexError as e: + pass # Pass no hace nada. Usualmente harias alguna recuperacion aqui. + +# Python oferce una abstracción fundamental llamada Iterable. +# Un iterable es un objeto que puede ser tratado como una sequencia. +# El objeto es retornado por la función 'range' es un iterable. + +dicc_lleno = {"uno": 1, "dos": 2, "tres": 3} +nuestro_iterable = dicc_lleno.keys() +print(nuestro_iterable) #=> range(1,10). Este es un objeto que implementa nuestra interfaz Iterable + +Podemos recorrerla. +for i in nuestro_iterable: + print(i) # Imprime uno, dos, tres + +# Aunque no podemos selecionar un elemento por su índice. +nuestro_iterable[1] # Genera un TypeError + +# Un iterable es un objeto que sabe como crear un iterador. +nuestro_iterator = iter(nuestro_iterable) + +# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos. +# Obtenemos el siguiente objeto llamando la función __next__. +nuestro_iterator.__next__() #=> "uno" + +# Mantiene el estado mientras llamamos __next__. +nuestro_iterator.__next__() #=> "dos" +nuestro_iterator.__next__() #=> "tres" + +# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator. +nuestro_iterator.__next__() # Genera StopIteration + +# Puedes obtener todos los elementos de un iterador llamando a list() en el. +list(dicc_lleno.keys()) #=> Retorna ["uno", "dos", "tres"] + + + +#################################################### +## 4. Funciones +#################################################### + +# Usa 'def' para crear nuevas funciones +def add(x, y): + print("x es {} y y es {}".format(x, y)) + return x + y # Retorna valores con una la declaración return + +# Llamando funciones con parámetros +add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11 + +# Otra forma de llamar funciones es con argumentos de palabras claves +add(y=6, x=5) # Argumentos de palabra clave pueden ir en cualquier orden. + + +# Puedes definir funciones que tomen un número variable de argumentos +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Puedes definir funciones que toman un número variable de argumentos +# de palabras claves +def keyword_args(**kwargs): + return kwargs + +# Llamémosla para ver que sucede +keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"} + + +# You can do both at once, if you like# Puedes hacer ambas a la vez si quieres +def todos_los_argumentos(*args, **kwargs): + print args + print kwargs +""" +todos_los_argumentos(1, 2, a=3, b=4) imprime: + (1, 2) + {"a": 3, "b": 4} +""" + +# ¡Cuando llames funciones, puedes hacer lo opuesto a varargs/kwargs! +# Usa * para expandir tuplas y usa ** para expandir argumentos de palabras claves. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +todos_los_argumentos(*args) # es equivalente a foo(1, 2, 3, 4) +todos_los_argumentos(**kwargs) # es equivalente a foo(a=3, b=4) +todos_los_argumentos(*args, **kwargs) # es equivalente a foo(1, 2, 3, 4, a=3, b=4) + +# Python tiene funciones de primera clase +def crear_suma(x): + def suma(y): + return x + y + return suma + +sumar_10 = crear_suma(10) +sumar_10(3) #=> 13 + +# También hay funciones anónimas +(lambda x: x > 2)(3) #=> True + +# Hay funciones integradas de orden superior +map(sumar_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Podemos usar listas por comprensión para mapeos y filtros agradables +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Classes +#################################################### + + +# Heredamos de object para obtener una clase. +class Humano(object): + + # Un atributo de clase es compartido por todas las instancias de esta clase + especie = "H. sapiens" + + # Constructor basico + def __init__(self, nombre): + # Asigna el argumento al atributo nombre de la instancia + self.nombre = nombre + + # Un metodo de instancia. Todos los metodos toman self como primer argumento + def decir(self, msg): + return "%s: %s" % (self.nombre, msg) + + # Un metodo de clase es compartido a través de todas las instancias + # Son llamados con la clase como primer argumento + @classmethod + def get_especie(cls): + return cls.especie + + # Un metodo estatico es llamado sin la clase o instancia como referencia + @staticmethod + def roncar(): + return "*roncar*" + + +# Instancia una clase +i = Humano(nombre="Ian") +print i.decir("hi") # imprime "Ian: hi" + +j = Humano("Joel") +print j.decir("hello") #imprime "Joel: hello" + +# Llama nuestro método de clase +i.get_especie() #=> "H. sapiens" + +# Cambia los atributos compartidos +Humano.especie = "H. neanderthalensis" +i.get_especie() #=> "H. neanderthalensis" +j.get_especie() #=> "H. neanderthalensis" + +# Llama al método estático +Humano.roncar() #=> "*roncar*" + + +#################################################### +## 6. Módulos +#################################################### + +# Puedes importar módulos +import math +print(math.sqrt(16)) #=> 4 + +# Puedes obtener funciones específicas desde un módulo +from math import ceil, floor +print(ceil(3.7)) #=> 4.0 +print(floor(3.7))#=> 3.0 + +# Puedes importar todas las funciones de un módulo +# Precaución: Esto no es recomendable +from math import * + +# Puedes acortar los nombres de los módulos +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Los módulos de Python son sólo archivos ordinarios de Python. +# Puedes escribir tus propios módulos e importarlos. El nombre del módulo +# es el mismo del nombre del archivo. + +# Puedes encontrar que funciones y atributos definen un módulo. +import math +dir(math) + + +#################################################### +## 7. Avanzado +#################################################### + +# Los generadores te ayudan a hacer un código perezoso (lazy) +def duplicar_numeros(iterable): + for i in iterable: + yield i + i + +# Un generador cera valores sobre la marcha. +# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración. +# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'. +# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse. +_rango = range(1, 900000000) +# Duplicará todos los números hasta que un resultado >= se encuentre. +for i in duplicar_numeros(_rango): + print(i) + if i >= 30: + break + + +# Decoradores +# en este ejemplo 'pedir' envuelve a 'decir' +# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar +from functools import wraps + + +def pedir(_decir): + @wraps(_decir) + def wrapper(*args, **kwargs): + mensaje, decir_por_favor = _decir(*args, **kwargs) + if decir_por_favor: + return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(") + return mensaje + + return wrapper + + +@pedir +def say(decir_por_favor=False): + mensaje = "¿Puedes comprarme una cerveza?" + return mensaje, decir_por_favor + + +print(decir()) # ¿Puedes comprarme una cerveza? +print(decir(decir_por_favor=True)) # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :() +``` + +## ¿Listo para más? + +### Gratis y en línea + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/3/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +### Encuadernados + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown new file mode 100644 index 00000000..66a5d0fe --- /dev/null +++ b/es-es/ruby-es.html.markdown @@ -0,0 +1,377 @@ +--- +language: ruby +filename: learnruby-es.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] +translators: + - ["Camilo Garrido", "http://www.twitter.com/hirohope"] +lang: es-es +--- + +```ruby +# Esto es un comentario + +=begin +Este es un comentario multilínea +Nadie los usa. +Tu tampoco deberías +=end + +# Lo primero y principal: Todo es un objeto + +# Los números son objetos + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Un poco de aritmética básica +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# La aritmética es sólo azúcar sintáctico +# para llamar un método de un objeto +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Los valores especiales son objetos +nil # Nada que ver aqui +true # Verdadero +false # Falso + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Igualdad +1 == 1 #=> true +2 == 1 #=> false + +# Desigualdad +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# Además de 'false', 'nil' es otro valor falso + +!nil #=> true +!false #=> true +!0 #=> false + +# Más comparaciones +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Los strings son objetos + +'Soy un string'.class #=> String +"Soy un string también".class #=> String + +referente = "usar interpolacion de strings" +"Yo puedo #{referente} usando strings de comillas dobles" +#=> "Yo puedo usar interpolacion de strings usando strings de comillas dobles" + + +# Imprime a la salida estándar +puts "¡Estoy imprimiendo!" + +# Variables +x = 25 #=> 25 +x #=> 25 + +# Nota que la asignación retorna el valor asignado +# Esto significa que puedes hacer múltiples asignaciones: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Por convención, usa snake_case para nombres de variables +snake_case = true + +# Usa nombres de variables descriptivos +ruta_para_la_raiz_de_un_projecto = '/buen/nombre/' +ruta = '/mal/nombre/' + +# Los símbolos (son objetos) +# Los símbolos son inmutables, constantes reusables representadas internamente por un +# valor entero. Son usalmente usados en vez de strings para expresar eficientemente +# valores específicos y significativos + +:pendiente.class #=> Symbol + +status = :pendiente + +status == :pendiente #=> true + +status == 'pendiente' #=> false + +status == :aprovado #=> false + +# Arreglos + +# Esto es un arreglo +[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Arreglos pueden contener elementos de distintos tipos + +arreglo = [1, "hola", false] #=> => [1, "hola", false] + +# Arreglos pueden ser indexados +# Desde el frente +arreglo[0] #=> 1 +arreglo[12] #=> nil + +# Tal como la aritmética, el acceso como variable[índice] +# es sólo azúcar sintáctica +# para llamar el método [] de un objeto +arreglo.[] 0 #=> 1 +arreglo.[] 12 #=> nil + +# Desde el final +arreglo[-1] #=> 5 + +# Con un índice de inicio y final +arreglo[2, 4] #=> [3, 4, 5] + +# O con rango +arreglo[1..3] #=> [2, 3, 4] + +# Añade elementos a un arreglo así +arreglo << 6 #=> [1, 2, 3, 4, 5, 6] + +# Hashes son los diccionarios principales de Ruby con pares llave/valor. +# Hashes se denotan con llaves: +hash = {'color' => 'verde', 'numero' => 5} + +hash.keys #=> ['color', 'numero'] + +# Hashes pueden buscar rápidamente una llave: +hash['color'] #=> 'verde' +hash['numero'] #=> 5 + +# Preguntarle a un hash por una llave que no existe retorna 'nil': +hash['nada aqui'] #=> nil + +# Itera sobre un hash con el método 'each': +hash.each do |k, v| + puts "#{k} is #{v}" +end + +# Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave: + +nuevo_hash = { defcon: 3, accion: true} + +nuevo_hash.keys #=> [:defcon, :accion] + +# Tip: Tanto los arreglos como los hashes son Enumerable (enumerables) +# Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más + +# Estructuras de Control + +if true + "declaracion 'if'" +elsif false + "else if, opcional" +else + "else, tambien opcional" +end + +for contador in 1..5 + puts "iteracion #{contador}" +end +#=> iteracion 1 +#=> iteracion 2 +#=> iteracion 3 +#=> iteracion 4 +#=> iteracion 5 + +# Aunque +# Nadie usa los ciclos `for` +# Usa `each`, así: + +(1..5).each do |contador| + puts "iteracion #{contador}" +end +#=> iteracion 1 +#=> iteracion 2 +#=> iteracion 3 +#=> iteracion 4 +#=> iteracion 5 + +counter = 1 +while counter <= 5 do + puts "iteracion #{counter}" + counter += 1 +end +#=> iteracion 1 +#=> iteracion 2 +#=> iteracion 3 +#=> iteracion 4 +#=> iteracion 5 + +nota = 'B' + +case nota +when 'A' + puts "Muy bien muchacho" +when 'B' + puts "Mejor suerte para la proxima" +when 'C' + puts "Puedes hacerlo mejor" +when 'D' + puts "Sobreviviendo" +when 'F' + puts "¡Reprobaste!" +else + puts "Sistema alternativo de notas, ¿eh?" +end + +# Funciones + +def doble(x) + x * 2 +end + +# Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción +doble(2) #=> 4 + +# Paréntesis son opcionales cuando el resultado es ambiguo +doble 3 #=> 6 + +doble doble 3 #=> 12 + +def suma(x,y) + x + y +end + +# Arguméntos del método son separados por coma +suma 3, 4 #=> 7 + +suma suma(3,4), 5 #=> 12 + +# yield +# Todos los métodos tienen un parámetro de bloqueo opcional e implícitp +# puede llamarse con la palabra clave 'yield' + +def alrededor + puts "{" + yield + puts "}" +end + +alrededor { puts 'hola mundo' } + +# { +# hola mundo +# } + + +# Define una clase con la palabra clave 'class' +class Humano + + # Una variable de clase. Es compartida por todas las instancias de la clase. + @@species = "H. sapiens" + + # Inicializador Básico + def initialize(nombre, edad=0) + # Asigna el argumento a la variable de instancia 'nombre' + @nombre = nombre + # Si no dan edad, se usará el valor por defecto en la lista de argumentos. + @edad = edad + end + + # Método 'setter' (establecer) básico + def nombre=(nombre) + @nombre = nombre + end + + # Método 'getter' (obtener) básico + def nombre + @nombre + end + + # Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia. + # Sólo puede ser llamado en la clase, no por una instancia. + def self.decir(mensaje) + puts "#{mensaje}" + end + + def especie + @@especie + end + +end + + +# Instancia una clase +jim = Humano.new("Jim Halpert") + +dwight = Humano.new("Dwight K. Schrute") + +# Llamemos un par de métodos +jim.especie #=> "H. sapiens" +jim.nombre #=> "Jim Halpert" +jim.nombre = "Jim Halpert II" #=> "Jim Halpert II" +jim.nombre #=> "Jim Halpert II" +dwight.especie #=> "H. sapiens" +dwight.nombre #=> "Dwight K. Schrute" + +# Llama el método de clase +Humano.decir("Hi") #=> "Hi" + +# Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia. +# Variables de clase son compartidas a través de la clase y todos sus descendientes. + +# clase base +class Humano + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(valor) + @@foo = valor + end +end + +# clase derivada +class Trabajador < Humano +end + +Humano.foo # 0 +Trabajador.foo # 0 + +Humano.foo = 2 # 2 +Trabajador.foo # 2 + +# Las variables de instancia de la clase no son compartidas por los descendientes de la clase. + +class Humano + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(valor) + @bar = valor + end +end + +class Doctor < Humano +end + +Human.bar # 0 +Doctor.bar # nil + +``` diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown new file mode 100644 index 00000000..7c2f4bd2 --- /dev/null +++ b/es-es/whip-es.html.markdown @@ -0,0 +1,255 @@ +--- +language: whip +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +author: Tenor Biel +author_url: http://github.com/L8D +filename: whip-es.lisp +lang: es-es +--- +Tutorial de Whip en español. + +Whip es un dialecto de LISP hecho para escribir código y conceptos +simples. Ha tomado prestado bastante de la sintaxis de Haskell +(un lenguaje no relacionado). + +Esta documentación fue escrita por el creador del lenguaje + +```scheme +; Los comentarios son como en LISP, con punto y coma... + +; La mayoría de las sentencias de primer nivel están dentro de +; "formas". Una forma no es más que cosas dentro de paréntesis +no_en_la_forma +(en_la_form) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 1. Números, Strings y Operadores + +;Whip tiene un tipo para números (es el estándar 64-bit IEEE 754 double, de JS) +3 ; => 3 +1.5 ; => 1.5 + +; Las funciones son llamadas si son el primer elemento de una forma +(funcion_llamada argumentos) + +; La mayoría de los operadores se hacen con funciones +; Toda la aritmética básica es bastante estándar +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 +; incluso el módulo +(% 9 4) ; => 1 +; división impar al estilo de JavaScript. +(/ 5 2) ; => 2.5 + +; Las formas anidadas funcionan como se espera. +(* 2 (+ 1 3)) ; => 8 + +; Hay un tipo booleano. +true +false + +; Los Strings son creados con comillas dobles ". +"Hola mundo" + +; Los caracteres solos se declaran con comillas simples '. +'a' + +; La negación usa la función 'not'. +(not true) ; => false +(not false) ; => true + +; La mayoría de las funcions que no vienen de Haskell tienen +; atajos. La función 'not' también se puede declarar con '!'. +(! (! true)) ; => true + +; La igualdad es `equal` o `=`. +(= 1 1) ; => true +(equal 2 1) ; => false + +; Por ejemplo, la desigualdad sería combinar la función 'not' con +; la función de igualdad +(! (= 2 1)) ; => true + +; Más comparaciones +(< 1 10) ; => true +(> 1 10) ; => false +; y su contraparte textual. +(lesser 1 10) ; => true +(greater 1 10) ; => false + +; Los Strings pueden concatenarse con la función +. +(+ "Hola " "mundo!") ; => "Hello world!" + +; También puedes usar las comparativas de JavaScript +(< 'a' 'b') ; => true +; ...y la coerción de tipos +(= '5' 5) + +; La función 'at' o @ accesa a los caracteres dentro de los strings, +; empezando en 0. +(at 0 'a') ; => 'a' +(@ 3 "foobar") ; => 'b' + +; También están las variables `null` and `undefined`. +null; usado para indicar una falta de valor deliberada. +undefined; usado para indicar un valor que aún no está definido. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 2. Variables, Listas y Diccionarios + +; Las variables son declaradas con las funciones `def` o `let`. +; Las variables que aún no son asignadas tendrán el valor `undefined`. +(def mi_variable 5) +; `def` asignará la variable al contexto global. +; `let` asignará la variable al contexto local, +; y tiene una sintaxis distinta. +(let ((mi_variable 5)) (+ mi_variable 5)) ; => 10 +(+ mi_variable 5) ; = undefined + 5 => undefined + +; Las listas son arreglos de valores de cualquier tipo. +; Básicamente, son formas sin funciones al inicio. +(1 2 3) ; => [1, 2, 3] (sintaxis JavaScript) + +; Los diccionarios son el equivalente en Whip de los 'objetos' de JavaScript, +; los 'dicts' de Python o los 'hashes' de Ruby: una colección desordenada +; de pares llave-valor +{"llave1" "valor1" "llave2" 2 3 3} + +; Las llaves son sólo valores, identificadores, números o strings. +(def mi_diccionario {mi_llave "mi_valor" "mi otra llave" 4}) +; Pero con Whip, los diccionarios son leidos así: +; "llave" "espacio en blanco" "valor" "espacio en blanco" +{"llave" "valor" +"otra llave" +1234 +} + +; Las definiciones de los diccionarios pueden accesarse con la función @ +; (como los strings y las listas) +(@ "mi otra llave" mi_diccionario) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 3. Logica y secuencias de control + +; La funcion `if` es bastante simple, aunque distinta que en otros lenguajes. +(if true "regresa esto si es true" "regresa esto si es false") +; => "regresa esto si es true" + +; Y para el operador ternario `?` +(? false true false) ; => false + +? `both` es un 'y' lógico, mientras que la función `either` es un 'o'. +(both true true) ; => true +(both true false) ; => false +(either true false) ; => true +(either false false) ; => false +; Y sus atajos son '&' y '^' respectivamente +; & => both +; ^ => either +(& true true) ; => true +(^ false true) ; => true + +;;;;;;;;; +; Lambdas + +; Las Lambdas en Whip son declaradas con las funciones `lambda` o `->`. +; Las funciones regulares en realidad sólo son lambdas con nombre. +(def mi_funcion (-> (x y) (+ (+ x y) 10))) +; | | | | +; | | | valor regresado(estas son las variables argumentos) +; | | argumentos +; | declaración de lambda +; | +; nombre de la lambda + +(mi_funcion 10 10) ; = (+ (+ 10 10) 10) => 30 + +; Obviamente, todas las lambdas por definición son anónimas y +; técnicamente siempre usadas anónimamente. Redundancia. +((lambda (x) x) 10) ; => 10 + +;;;;;;;;;;;;;;;; +; Comprensiones + +; `range` o `..` genera una lista de números que comprende +; cada entero dentro de los argumentos. +(range 1 5) ; => (1 2 3 4 5) +(.. 0 2) ; => (0 1 2) + +; `map` aplica su primer argumento (que debe ser una función) +; al siguiente argumento (que es una lista). +(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4) + +; Reducir +(reduce + (.. 1 5)) +; equivale a +((+ (+ (+ 1 2) 3) 4) 5) + +; Nota: map y reduce no tienen atajos. + +; `slice` o `\` es idéntico a la función .slice() de JavaScript +; Pero toma la lista del primer argumento, no del último. +(slice (.. 1 5) 2) ; => (3 4 5) +(\ (.. 0 100) -5) ; => (96 97 98 99 100) + +; `append` o `<<` se explica solo. +(append 4 (1 2 3)) ; => (1 2 3 4) +(<< "bar" ("foo")) ; => ("foo" "bar") + +; Length se explica solo. +(length (1 2 3)) ; => 3 +(_ "foobar") ; => 6 + +;;;;;;;;;;;;;;; +; Elementos de Haskell + +; Primer elemento en una lista +(head (1 2 3)) ; => 1 + +; Lista del segundo elemento al último en una lista +(tail (1 2 3)) ; => (2 3) + +; Último elemento en una lista +(last (1 2 3)) ; => 3 + +; Contrario a `tail` +(init (1 2 3)) ; => (1 2) + +; Lista del primer elemento al argumento +(take 1 (1 2 3 4)) ; (1 2) + +; Contrario a `take` +(drop 1 (1 2 3 4)) ; (3 4) + +; Valor más pequeño de una lista +(min (1 2 3 4)) ; 1 + +; Valor más grande de una lista +(max (1 2 3 4)) ; 4 + +; Comprobar que el elemento está en la lista +(elem 1 (1 2 3)) ; true +(elem "foo" {"foo" "bar"}) ; true +(elem "bar" {"foo" "bar"}) ; false + +; Invertir el orden de la lista +(reverse (1 2 3 4)) ; => (4 3 2 1) + +; Comprobar si un elemento es par o impar +(even 1) ; => false +(odd 1) ; => true + +; Separar string en una lista de strings, separados por espacios +(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese") +; Juntar lista de strings. +(unwords ("foo" "bar")) ; => "foobar" +(pred 21) ; => 20 +(succ 20) ; => 21 +``` + +Para más información, revisa el [repositorio](http://github.com/L8D/whip) diff --git a/es-es/xml-es.html.markdown b/es-es/xml-es.html.markdown new file mode 100644 index 00000000..2e9326cf --- /dev/null +++ b/es-es/xml-es.html.markdown @@ -0,0 +1,131 @@ +--- +language: xml +filename: learnxml.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +lang: es-es +--- +XML es un lenguaje diseñado para guardar y transportar datos + +A diferencia de HTML, XML no especifica cómo desplegar la información, +sólo la guarda. + +* Sintaxis XML + +```xml +<!-- Los comentarios en XML son de esta forma --> + +<?xml version="1.0" encoding="UTF-8"?> +<tiendaDeLibros> + <libro categoria="COCINA"> + <titulo lenguaje="en">Everyday Italian</titulo> + <autor>Giada De Laurentiis</autor> + <anio>2005</anio> + <precio>30.00</precio> + </libro> + <libro categoria="INFANTES"> + <titulo lenguaje="en">Harry Potter</titulo> + <autor>J K. Rowling</autor> + <anio>2005</anio> + <precio>29.99</precio> + </libro> + <libro categoria="WEB"> + <titulo lenguaje="en">Learning XML</titulo> + <autor>Erik T. Ray</autor> + <anio>2003</anio> + <precio>39.95</precio> + </libro> +</tiendaDeLibros> + +<!-- Este es un archivo típico de XML. + Empieza con una declaración de metadatos (opcional). + + XML usa una estructura de árbol. El nodo raíz es 'tiendaDeLibros', el cual + tiene tres nodos hijos, todos llamados 'libros'. + Esos nodos tienen más nodos hijos, y así continúa... + + Los nodos son creados usando tags que abren y cierran, y los hijos + son sólo nodos entre estas tags.--> + + +<!-- XML guarda dos tipos de datos: + 1 - Atributos -> Son los metadatos de un nodo. + Usualmente el parseador XML usa esta información para guardar los datos + apropiadamente. Aparecen con el formato (nombre="valor") dentro de la + tag que abre. + 2 - Elementos -> Ese es el dato puro. + Eso es lo que el parseador recuperará del archivo XML. + Los elementos aparecen entre las tags que abren y cierran.--> + + +<!-- Debajo, un elemento con dos atributos. --> +<archivo tipo="gif" id="4293">computer.gif</archivo> + + +``` + +* Documentos con buen formato x Validación + +Un documento XML está bien formado cuando es sintácticamente correcto. +Aún esto, es posible inyectar más restricciones en el documento, +usando definiciones de documento, así como DTD o XML Schemas. + +Un documento XML que sigue a una definición de documento (un esquema) es +válida. + +Con esta herramienta puedes validar datos XML fuera de la aplicación + +```xml + +<!-- Debajo puedes encontrar una versión simplificada del documento + tiendaDeLibros en adición a la definición DTD.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "tiendaDeLibros.dtd"> +<tiendaDeLibros> + <libro categoriq="COCINA"> + <titulo>Everyday Italian</titulo> + <precio>30.00</precio> + </libro> +</tiendaDeLibros> + +<!-- El DTD de este documento podría verse algo así:--> + +<!DOCTYPE note +[ +<!ELEMENT tiendaDeLibros (libro+)> +<!ELEMENT libro (titulo,precio)> +<!ATTLIST libro categoria CDATA "Literatura"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT precio (#PCDATA)> +]> + +<!--El DTD empieza con una declaración. + Después el nodo raíz es declarado, requiriendo 1 o más nodos 'libro' + Cada 'libro' debe contener exactamente un 'titulo' y un 'precio' y + un atributo llamado 'categoria', con "Literatura" como su valor + default. + Los nodos 'titulo' y 'precio' contienen datos de caracteres + parseados. + + El DTD puede ser declarado dentro del XML mismo.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT tiendaDeLibros (libro+)> +<!ELEMENT libro (titulo,precio)> +<!ATTLIST libro categoria CDATA "Literatura"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT precio (#PCDATA)> +]> +<tiendaDeLibros> + <libro categoriq="COCINA"> + <titulo>Everyday Italian</titulo> + <precio>30.00</precio> + </libro> +</tiendaDeLibros> +``` diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown new file mode 100644 index 00000000..a5157b5d --- /dev/null +++ b/es-es/yaml-es.html.markdown @@ -0,0 +1,151 @@ +--- +language: yaml +lang: es-es +filename: learnyaml-es.yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +translators: + - ["Daniel Zendejas","https://github.com/DanielZendejas"] +--- +Tutorial de YAML en español. + +YAML es un lenguaje de serialización de datos diseñado para ser +leído y escrito por humanos. + +Basa su funcionalidad en JSON, con la adición de líneas nuevas +e indentación inspirada en Python. A diferencia de Python, YAML +no permite tabs literales. + +```yaml +# Los comentarios en YAML se ven así. + +################### +# TIPOS ESCALARES # +################### + +# Nuestro objeto raíz (el cual es el mismo a lo largo de todo el +# documento) será un mapa, equivalente a un diccionario, hash, +# u objeto en otros lenguajes. + +llave: valor +otra_llave: Otro valor +un_valor_numerico: 100 +notacion_cientifica: 1e+12 +booleano: true +valor_nulo: null +llave con espacios: valor +# Nótese que los strings no deben estar entre comillas, aunqué también es válido. +llave: "Un string, entre comillas." +"Las llaves tambien pueden estar entre comillas.": "valor entre comillas" + +# Los strings de líneas múltiples pueden ser escritos +# como un 'bloque literal' (usando pipes |) +# o como un 'bloque doblado' (usando >) + +bloque_literal: | + Este bloque completo de texto será preservado como el valor de la llave + 'bloque_literal', incluyendo los saltos de línea. + + Se continúa guardando la literal hasta que se cese la indentación. + Cualquier línea que tenga más indentación, mantendrá los espacios dados + (por ejemplo, estas líneas se guardarán con cuatro espacios) + +nloque_doblado: > + De la misma forma que el valor de 'bloque_literal', todas estas + líneas se guardarán como una sola literal, pero en esta ocasión todos los + saltos de línea serán reemplazados por espacio. + + Las líneas en blanco, como la anterior, son convertidos a un salto de línea. + + Las líneas con mayor indentación guardan sus saltos de línea. + Esta literal ocuparán dos líneas. + +######################## +# TIPOS DE COLECCIONES # +######################## + +# La indentación se usa para anidar. +un_mapa_indentado: + llave: valor + otra_llave: otro valor + otro_mapa_indentado: + llave_interna: valor_interno + +# Las llaves de los mapas no deben ser strings necesariamente +0.25: una llave numérica + +# Las llaves también pueden ser objetos de multi línea, usando ? para indicar +# el inicio de una llave +? | + Esto es una llave + que tiene múltiples líneas +: y este es su valor + +# YAML tambien permite colecciones como llaves, pero muchos lenguajes de +# programación se quejarán. + +# Las secuencias (equivalentes a listas o arreglos) se ven así: +una_secuencia: + - Item 1 + - Item 2 + - 0.5 # las secuencias pueden tener distintos tipos en su contenido. + - Item 4 + - llave: valor + otra_llave: otro_valor + - + - Esta es una secuencia + - ...dentro de otra secuencia + +# Dado que todo JSON está incluído dentro de YAML, también puedes escribir +# mapas con la sintaxis de JSON y secuencias: +mapa_de_json: {"llave": "valor"} +secuencia_de_json: [3, 2, 1, "despegue"] + +################################## +# CARACTERÍSTICAS EXTRAS DE YAML # +################################## + +# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten +# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo +# a continuación, ambas llaves tendrán el mismo valor: +contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves +otra_ancla: *nombre_del_ancla + +# YAML también tiene tags, que puedes usar para declarar tipos explícitamente. +string_explícito: !!str 0.5 +# Algunos parseadores implementar tags específicas del lenguaje, como el +# que se muestra a continuación, encargado de manejar números complejos en +# Python: +numero_complejo_python: !!python/complex 1+2j + +######################## +# TIPOS EXTRAS EN YAML # +######################## + +# Stirngs y números no son los únicos escalares que YAML puede entener. +# YAML también puede parsear fechas en formato ISO . +fechaHora: 2001-12-15T02:59:43.1Z +fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5 +fecha: 2002-12-14 + +# La tag !!binary indica que un string es, en realidad, un blob +# representado en base-64. +archivo_gif: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML también tiene un tipo set, que se ve de la siguiente forma: +set: + ? item1 + ? item2 + ? item3 + +# Al igual que Python, los sets sólo son mapas con valores nulos. +# El ejemplo de arriba es equivalente a: +set2: + item1: null + item2: null + item3: null +``` diff --git a/fa-ir/brainfuck.html.markdown b/fa-ir/brainfuck.html.markdown new file mode 100644 index 00000000..ef2bcba3 --- /dev/null +++ b/fa-ir/brainfuck.html.markdown @@ -0,0 +1,81 @@ +--- +language: brainfuck +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] +lang: fa-ir +--- + +<p dir='rtl'>برین فاک زبان برنامه نویسی تورینگ کامل بی نهایت ساده ایست که دارای فقط هشت</p> +<p dir='rtl'>دستور است.</p> + +<p dir='rtl'>هر کارکتری به جر کارکتر های زیر در این زبان در نظر گرفته نمیشود.</p> + + +`>` `<` `+` `-` `.` `,` `[` `]` + +<p dir='rtl'>برین فاک به صورت یک آرایه ی سی هزار خانه ای کار میکند که در ابتدا تمامی خانه های آن صفر هستند.</p> +<p dir='rtl'>همچنین یک اشاره گر در این برنامه به خانه ی فعلی اشاره میکند.</p> + +<p dir='rtl'>در زیر هشت دستور این زبان شرح داده شده است:</p> + +<p dir='rtl'>`+` : یک عدد به خانه ی فعلی اضافه می کند. +<p dir='rtl'>`-` : یک عدد از خانه ی فعلی کم می کند. </p> +<p dir='rtl'>`>` : اشاره گر به خانه ی بعدی میرود -- به راست</p> +<p dir='rtl'>`<` : اشاره گر به خانه ی قبلی میرود -- به چپ</p> +<p dir='rtl'>`.` : کارکتر اسکی معادل مقدار خانه ی فعلی را چاپ میکند. -- به عنوان مثال 65 برای A</p> +<p dir='rtl'>`,` : یک کارکتر را از ورودی خوانده و مقدار آن را در خانه ی فعلی زخیره میکند.</p> +<p dir='rtl'>`[` : اگر مقدار خانه ی فعلی صفر باشد به محل بسته شدن کروشه جهش میکند. -- و از همه ی دستور های بین آن صرف نظر میشود.</p> +<p dir='rtl'>در غیر این صورت به دستور بعدی میرود.</p> +<p dir='rtl'>`]` : اگر مقدار خانه ی فعلی صفر باشد به خانه ی بعدی و در غیر این صورت به محل باز شدن کروشه جهش می کند. -- به عقب</p> + +<p dir='rtl'>دو علامت کروشه امکان ایجاد حلقه را فراهم میکنند.</p> + +<p dir='rtl'>در اینجا یک برنامه ی ساره برین فاک را مشاهده میکنید.</p> + +``` +++++++ [ > ++++++++++ < - ] > +++++ . +``` + +<p dir='rtl'>این برنامه کارکتر A را بر روی خروجی چاپ میکند.</p> +<p dir='rtl'>در این برنامه خانه ی اول به عنوان متغیر حلقه و خانه ی دوم برای مقدار عددی A</p> +<p dir='rtl'>ابتدا عدد شش در خانه ی اول ایجاد شده. سپس برنامه وارد یک حلقه میشود که در هر بار </p> +<p dir='rtl'>تکرار آن اشاره گر به خانه ی دوم رفته و ده بار به خانه ی فعلی اضافه می کند.</p> +<p dir='rtl'>-- و در انتهای حلقه به خانه ی اول برگشته تا حلقه کنترل شود</p> +<p dir='rtl'>بعد از اتمام حلقه به خانه ی دوم میرود و پنج بار به این خانه اضافه کرده و سپس آنرا چاپ میکند.</p> + +``` +, [ > + < - ] > . +``` + +<p dir='rtl'>در این برنامه ابتدا یک کارکتر از ورودی خوانده می شود. سپس یک حلقه به تعداد بار مقدار</p> +<p dir='rtl'>عددی کارکتر، یک عدد به خانه ی دوم اضافه می کند. با این کار در واقع برنامه مقدار ورودی را در خانه ی </p> +<p dir='rtl'>دوم کپی می کند. و در نهایت آن را برروی خروجی چاپ می کند.</p> + +<p dir='rtl'>توجه داشته باشید که ردر بالا فواصل بین دستور ها فقط برای خوانایی بیشتر گذاشته شده اند.</p> +<p dir='rtl'>در واقع برنامه بالا به شکل زیر صحیح می باشد.</p> + +``` +,[>+<-]>. +``` + +<p dir='rtl'>حال سعی کنید ببینید که برنامه ی زیر چه کاری انجام می دهد؟</p> + +``` +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> +``` + +<p dir='rtl'>این برنامه دو عدد را از ورودی خوانده و با هم ضرب می کند.</p> + +<p dir='rtl'>ابتدا دو عدد از ورودی خوانده می شوند. سپس حلقه ی بیرونی بر روی خانه شماره یک شروع میشود.</p> +<p dir='rtl'>و درون آن حلقه ی دیگری بر روی خانه ی دوم شروع میشود که خانه ی 3 را زیاد میکند.</p> +<p dir='rtl'>ولی مشکلی که در اینجا به وجود می آید اینست که در پایان حلقه ی دوم مقدار خانه ی 2 صفر شده</p> +<p dir='rtl'>و مقدار اولیه ی آن از دست رفته است. برای حل این مشکل خانه ی شماره چهار هم زیاد میشود</p> +<p dir='rtl'>و در پایان حلقه مقدار آن به خانه 2 کپی میشود.</p> +<p dir='rtl'>در پایان خانه ی شماره 2 حاوی حاصلضرب خواهد بود.</p> + +<hr> + +<p dir='rtl'>و این همه ی برین فاک بود! خیلی ساده برای یادگیری ولی سنگین برای به کار بردن.</p> +<p dir='rtl'>حال می توانید برای تفریح مشغول نوشتن برنامه ی های مختلف با آن شوید.</p> +<p dir='rtl'>و یا یک اجرا کننده برین فاک را با یک زبان دیگر پیاده سازی کنید.</p> +<p dir='rtl'>و یا اگر خیلی دوست داشتید یک اجرا کننده ی برین فاک با برین فاک بنویسید!!</p> diff --git a/fa-ir/javascript.html.markdown b/fa-ir/javascript.html.markdown new file mode 100644 index 00000000..fe3555af --- /dev/null +++ b/fa-ir/javascript.html.markdown @@ -0,0 +1,553 @@ +--- +language: javascript +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] +translators: + - ["Mohammad Valipour", "https://github.com/mvalipour"] +filename: javascript-fa.js +lang: fa-ir +--- + +<p dir='rtl'> +جاوااسکریپت توسط برندن ایش از شرکت NetScape در سال 1995 ساخته شد. در ابتدا به عنوان یک زبان اسکریپتنویسی در کنار جاوا (که برای موارد پیچیده تر در طراحی وب در نظر گرفته میشد) مورد استفاده بود، ولی در پی نفوذ بسیار گسترده آن در وب و همچنین پشتیبانی پیش-ساخته آن در مرورگر ها، امروزه به مراتب بیشتر از جاوا در برنامه نویسی سمت-کاربر در وب به کار برده میشود. +با این حال جاوااسکریپت فقط محدود به مرورگر های وب نمیشود. Node.js پروژه ایست که یک نسخه ی مستقل از اجراکننده ی موتور جاوااسکریپت V8 از گوگل کروم را در اختیار قرار میده که هر روزه درحال محبوب تر شدن نیز هست. +</p> + +<p dir='rtl'> +قدر دان نظرات سازنده شما هستم! شما میتوانید از طریق زیر با من تماس بگیرید: +</p> + +[@adambrenecki](https://twitter.com/adambrenecki), or +[adam@brenecki.id.au](mailto:adam@brenecki.id.au). + +<p dir='rtl'> +// توضیحات همانند C هستند. توضیحات یک خطی با دو خط مورب شروع میشوند., +</p> + +<p dir='rtl'> +/* و توضیحات چند خطی با خط مورب-ستاره شروع، + و با ستاره-خط مورب ختم میشوند */ +</p> + +```js +// Comments are like C. Single-line comments start with two slashes, +/* and multiline comments start with slash-star + and end with star-slash */ +``` +<p dir='rtl'> +گزاره ها را میتوانید با نقطه ویرگول پایان دهید ; +</p> +```js +doStuff(); +``` +<p dir='rtl'> +ولی لزومی به این کار نیست. نقطه ویرگول به صورت خودکار در نظر گرفته میشوند. +</p> +<p dir='rtl'> +وقتی که خط جدیدی شروع میشود. مگر در موارد خاص. +</p> +```js +doStuff() +``` +<p dir='rtl'>برای اینگه درگیر آن موارد خاص نشویم، در اینجا از اون ها </p> +<p dir='rtl'>صرف نظر میکنیم.</p> + +<h2 dir='rtl'>1. اعداد، رشته ها و عملگرها</h2> + +<p dir='rtl'>جاوااسکریپت فقط یک نوع عدد دارد و آن عدد اعشاری 64 بیتی IEEE 754 است.</p> +<p dir='rtl'>نترسید! و نگران اعداد صحیح نباشید! این اعداد اعشاری دارای 54 بیت مانتیس هستند که قابلیت ذخیره ی </p> +<p dir='rtl'>دقیق اعداد صحیح تا مقدار تقریبی 9x10¹⁵ را دارند.</p> +```js +3; // = 3 +1.5; // = 1.5 +``` +<p dir='rtl'> +تمامی عملگر های محاسباتی آن طوری که انتظارش را دارید عمل خواهند کرد. +</p> +```js +1 + 1; // = 2 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 +``` +<p dir='rtl'>و این حتی شامل تقسیم هم میشود.</p> +```js +5 / 2; // = 2.5 +``` +<p dir='rtl'>عملگر های بیتی هم به همین شکل. وقتی از یک عملگر بیتی استفاده میکنید، عدد اعشاری شما</p> +<p dir='rtl'>به عدد صحیح علامت دار *تا 32 بیت* تبدیل میشود.</p> +```js +1 << 2; // = 4 +``` +<p dir='rtl'>عملیات داخل پرانتز تقدم بالاتری دارند.</p> +```js +(1 + 3) * 2; // = 8 +``` +<p dir='rtl'>سه مقدار خاص وجود دارند که در واقع مقادیر عددی نیستند:</p> +```js +Infinity; // result of e.g. 1/0 +-Infinity; // result of e.g. -1/0 +NaN; // result of e.g. 0/0 +``` +<p dir='rtl'>مقادیر بولی هم تعریف شده هستند:</p> +```js +true; +false; +``` +<p dir='rtl'>رشته ها با آپستروف و یا گیومه تعریف میشوند.</p> +```js +'abc'; +"Hello, world"; +``` +<p dir='rtl'>و منفی کردن شرط با علامت تعجب</p> +```js +!true; // = false +!false; // = true +``` +<p dir='rtl'>تساوی دو مقدار با ==</p> +```js +1 == 1; // = true +2 == 1; // = false +``` +<p dir='rtl'>و عدم تساوی با !=</p> +```js +1 != 1; // = false +2 != 1; // = true +``` +<p dir='rtl'>و سایر عمیلات های مقایسه</p> +```js +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true +``` +<p dir='rtl'>رشته ها با علامت جمع به یکدیگر متصل میشوند</p> +```js +"Hello " + "world!"; // = "Hello world!" +``` +<p dir='rtl'>و با علامت برگتر و یا کوچکتر با یکدیگر مقایسه میشوند.</p> +```js +"a" < "b"; // = true +``` +<p dir='rtl'>نوع متغیر برای عملیات مقایسه تطبیق داده میشود</p> +```js +"5" == 5; // = true +``` +<p dir='rtl'>مگر اینکه از سه مساوی استفاده شود!</p> +```js +"5" === 5; // = false +``` +<p dir='rtl'>با استفاده از charAt میتوانید به کارکتر های یک رشته دسترسی پیدا کنید.</p> +```js +"This is a string".charAt(0); +``` +<p dir='rtl'>از null برای نشان دادن عمدی مقدار هیج استفاده میشود.</p> +<p dir='rtl'>و از undefined برای نشان دادن اینکه در حال حاظر مقدار موجود نمی باشد، هرچند خود undefined یک مقدار محسوب میشود.</p> +```js +null; // used to indicate a deliberate non-value +undefined; // used to indicate a value is not currently present (although undefined + // is actually a value itself) +``` +<p dir='rtl'>false, null, undefined, NaN, 0 و "" مقدار نادرست و هر چیز دیگر مقدار درست طلقی میشوند.</p> +<p dir='rtl'>توجه داشته باشید که 0 نادرست و "0" درست طلقی میشوند حتی در عبارت 0=="0".</p> + +<h2 dir='rtl'> 2. متغیر ها، آرایه ها و شئ ها </h2> + +<p dir='rtl'>متغیر ها با کلید واژه var تعریف میشوند. اشیا در جاوااسکریپت دارای نوع پویا هستند، </p> +<p dir='rtl'>بدین شکل که برای تعریف نیازی به مشخص کردن نوع متعیر نیست. </p> +<p dir='rtl'>برای مقدار دهی از علامت مساوی استفاده میشود. </p> +```js +var someVar = 5; +``` + +<p dir='rtl'>اگر کلید واژه var را قرار ندهید، هیچ خطایی دریافت نخواهید کرد... </p> +```js +someOtherVar = 10; +``` + +<p dir='rtl'>در عوض متغیر شما در گستره ی کل برنامه تعریف شده خواهد بود. </p> + +<p dir='rtl'>متغیر هایی که تعریف شده ولی مقدار دهی نشوند، دارای مقدار undefined خواهند بود. </p> +```js +var someThirdVar; // = undefined +``` + +<p dir='rtl'>برای اعمال عملگر های محاسباتی، میانبر هایی وجود دارند: </p> +```js +someVar += 5; // equivalent to someVar = someVar + 5; someVar is 10 now +someVar *= 10; // now someVar is 100 +``` + +<p dir='rtl'>حتی از این هم کوتاهتر برای اضافه یا کم کردن یک عدد با مقدار یک. </p> +```js +someVar++; // now someVar is 101 +someVar--; // back to 100 +``` + +<p dir='rtl'>آرایه ها در واقع لیستی مرتب شده از مقادیر مختلف از هر نوعی هستند. </p> +```js +var myArray = ["Hello", 45, true]; +``` + +<p dir='rtl'>به اعضای یک آرایه میتوان از طریق قرار دادن کروشه در جلوی نام آن دسترسی پیدا کرد. </p> +<p dir='rtl'>نمایه ی آرایه از صفر شروع میشود. </p> +```js +myArray[1]; // = 45 +``` + +<p dir='rtl'>آرایه ها ناپایدار و دارای طول قابل تغییر هستند </p> +```js +myArray.push("World"); +myArray.length; // = 4 +``` + +<p dir='rtl'>در جاوااسکریپت، اشیاء چیزی شبیه دیکشنری و یا نقشه در زبان های دیگر هستند: </p> +<p dir='rtl'>یک مجموعه ی نامرتب از جفت های کلید-مقدار. </p> +```js +var myObj = {key1: "Hello", key2: "World"}; +``` + +<p dir='rtl'>کلید ها از نوع رشته هستند ولی در صورتی که مقدار معتبری برای اسم گزاری باشند نیازی به آوردن آنها درون گیومه نیست. </p> +```js +var myObj = {myKey: "myValue", "my other key": 4}; +``` + +<p dir='rtl'>اعضای یک شئ را نیز میتوانید با استفاده از کروشه در مقابل نام آنها استخراج کنید. </p> +```js +myObj["my other key"]; // = 4 +``` + +<p dir='rtl'>...و یا از طریق نقطه در صورتی که اسم عضو مورد نظر اسم معتبری برای اسم گزاری باشد.</p> +```js +myObj.myKey; // = "myValue" +``` + +<p dir='rtl'>اشیاء ناپایدار و قابل اضافه کردن عضو جدید هستند.</p> +```js +myObj.myThirdKey = true; +``` + +<p dir='rtl'>اگر سعی کنید عضوی را که وجود ندارد استخراج کنید، مقدار undefined را دریافت خواهید کرد. </p> +```js +myObj.myFourthKey; // = undefined +``` + +<h2 dir='rtl'>3. منطق و ساختار کنترل</h2> + +<p dir='rtl'>ساختار if به شکلی که انتظارش را دارید کار میکند.</p> +```js +var count = 1; +if (count == 3){ + // evaluated if count is 3 +} else if (count == 4) { + // evaluated if count is 4 +} else { + // evaluated if it's not either 3 or 4 +} +``` + +<p dir='rtl'>و همینطور حلقه while</p> +```js +while (true) { + // An infinite loop! +} +``` + +<p dir='rtl'>حلقه do-while شبیه while است با این تفاوت که حداقل یکبار اجرا میشود.</p> +```js +var input +do { + input = getInput(); +} while (!isValid(input)) +``` + +<p dir='rtl'>حلقه for همانند زبان C و جاوا کار می کند.</p> +<p dir='rtl'>مقدار دهی اولیه; شرط ادامه; چرخش حلقه</p> +```js +for (var i = 0; i < 5; i++){ + // will run 5 times +} +``` + +<p dir='rtl'>عملگر && و || به ترتیب "و" و "یا" ی منطقی هستند.</p> +```js +if (house.size == "big" && house.colour == "blue"){ + house.contains = "bear"; +} +if (colour == "red" || colour == "blue"){ + // colour is either red or blue +} +``` + +<p dir='rtl'>از || همچنین میتوان برای تعیین مقدار پیشفرض استفاده کرد.</p> +```js +var name = otherName || "default"; +``` + +<h2 dir='rtl'>4. توابع و مفاهیم گستره و بستار</h2> + +<p dir='rtl'>توابع در جاوااسکریپت با استفاده از کلیدواژه ی function تعریف میشوند.</p> +```js +function myFunction(thing){ + return thing.toUpperCase(); +} +myFunction("foo"); // = "FOO" +``` + +<p dir='rtl'>توابع در جاوااسکریپت نوعی شئ پایه محسوب میشوند، بنابر این می توانید آنها را به اشیاء مختلف</p> +<p dir='rtl'>اضافه کنید و یا به عنوان پارامتر به توابع دیگر ارسال کنید.</p> +<p dir='rtl'>- برای مثال وقتی که با یک رویداد کار میکنید.</p> +```js +function myFunction(){ + // this code will be called in 5 seconds' time +} +setTimeout(myFunction, 5000); +``` + +<p dir='rtl'>توجه کنید که setTimeout تابعی تعریف شده در جاوااسکریپت نیست، ولی مرورگر ها و node.js از آن پشتیبانی میکنند.</p> + + +<p dir='rtl'>توابع نیازی به داشتن اسم ندارند. برای مثال وقتی تابعی را به تابعی دیگر ارسال میکنید</p> +<p dir='rtl'>میتوانید آنرا به صورت بینام تعریف کنید.</p> +```js +setTimeout(function(){ + // this code will be called in 5 seconds' time +}, 5000); +``` + +<p dir='rtl'>توابع دارای محدوده ی متغیر های خود هستند.</p> +<p dir='rtl'>بر خلاف دیگر ساختار ها - مانند if</p> +```js +if (true){ + var i = 5; +} +i; // = 5 - not undefined as you'd expect in a block-scoped language +``` + +<p dir='rtl'>به همین دلیل الگوی خاصی به نام "تابعی که بلافاصله صدا زده میشود" پدید آمده </p> +<p dir='rtl'>تا از اضافه شدن متغیر های قسمتی از برنامه به گستره ی کلی برنامه جلوگیری شود.</p> +```js +(function(){ + var temporary = 5; + // We can access the global scope by assiging to the 'global object', which + // in a web browser is always 'window'. The global object may have a + // different name in non-browser environments such as Node.js. + window.permanent = 10; +})(); +temporary; // raises ReferenceError +permanent; // = 10 +``` + +<p dir='rtl'>یکی از برترین ویژگی های جاوااسکریپت مفهومی با نام بستار است</p> +<p dir='rtl'>بدین شکل که اگر تابعی درون تابع دیگری تعریف شود، تابع درونی به تمام متغیر های تابع خارجی دسترسی</p> +<p dir='rtl'>خواهد داشت، حتی بعد از اینکه تابع خارجی به اتمام رسیده باشد.</p> +```js +function sayHelloInFiveSeconds(name){ + var prompt = "Hello, " + name + "!"; + function inner(){ + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout is asynchronous, so the sayHelloInFiveSeconds function will + // exit immediately, and setTimeout will call inner afterwards. However, + // because inner is "closed over" sayHelloInFiveSeconds, inner still has + // access to the 'prompt' variable when it is finally called. +} +sayHelloInFiveSeconds("Adam"); // will open a popup with "Hello, Adam!" in 5s +``` + +<h2 dir='rtl'>5. دیگر اشیاء، سازنده ها و پیشنمونه ها</h2> + +<p dir='rtl'>اشیاء میتوانند تابع داشته باشند.</p> +```js +var myObj = { + myFunc: function(){ + return "Hello world!"; + } +}; +myObj.myFunc(); // = "Hello world!" +``` + +<p dir='rtl'>وقتی تابع یک شی صدا زده می شود، تابع میتواند به سایر مقادیر درون آن شی </p> +<p dir='rtl'>از طریق کلید واژه ی this دسترسی داشته باشد.</p> +```js +myObj = { + myString: "Hello world!", + myFunc: function(){ + return this.myString; + } +}; +myObj.myFunc(); // = "Hello world!" +``` + + +<p dir='rtl'>اینکه مقدار this چه باشد بستگی به این دارد که تابع چگونه صدا زده شود</p> +<p dir='rtl'>نه اینکه تابع کجا تعریف شده است.</p> +<p dir='rtl'>بنابر این تابع بالا اگر بدین شکل صدا زده شود کار نخواهد کرد</p> +```js +var myFunc = myObj.myFunc; +myFunc(); // = undefined +``` + + +<p dir='rtl'>به همین شکل، تابعی که در جای دیگر تعریف شده را میتوانید به یک شی الحاق کنید</p> +<p dir='rtl'>و بدین ترتیب تابع میتواند به مقادیر درون شی از طریق this دسترسی پیدا کند.</p> +```js +var myOtherFunc = function(){ + return this.myString.toUpperCase(); +} +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "HELLO WORLD!" +``` + + +<p dir='rtl'>اگر تابعی با کلید new صدا زده شوند، شی جدیدی ایجاد شده و تابع در گستره ی آن صدا زده میشود.</p> +<p dir='rtl'>توابعی که بدین شکل صدا زده شوند در واقع نقش سازنده را ایفا می کنند.</p> +```js +var MyConstructor = function(){ + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 +``` + + +<p dir='rtl'>تمامی اشیاء در جاوااسکریپت دارای یک پیش نمونه هستند</p> +<p dir='rtl'>به شکلی که اگر تابع صدا زده شده بر روی شی مستقیما روی آن تعریف نشده باشد</p> +<p dir='rtl'>اجرا کننده ی برنامه در لیست پیش نمونه به دنبال آن تابع خواهد گشت</p> + +<p dir='rtl'>برخی اجرا کننده های جاوااسکریپت به شما اجازه ی دسترسی به پیش نمونه های یک شی را از</p> +<p dir='rtl'>طریق عضو جادویی __proto__ میدهند.</p> +<p dir='rtl'>هرچند این به شناخت پیش نمونه ها کمک میکند ولی در حیطه ی جاوااسکریپت استاندارد قرار نمیگیرد.</p> +<p dir='rtl'>در ادامه شکل استاندارد پیش نمونه ها مورد بررسی قرار میگیرند.</p> +```js +var myObj = { + myString: "Hello world!", +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +}; +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 +``` + +<p dir='rtl'>این موضوع در مورد توابع نیز صدق میکند.</p> +```js +myObj.myFunc(); // = "hello world!" +``` + + +<p dir='rtl'>اگر عضو مورد نظر در پیش نمونه ی شی یافت نشود، پیش نمونه ی پیش نمونه جستجو شده و الی آخر</p> +```js +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true +``` + + +<p dir='rtl'>توجه داشته باشید که پیش نمونه ها کپی نمی شوند و هر شی جدید به پیش نمونه موجود اشاره میکند</p> +<p dir='rtl'>بدین ترتیب اگر تابعی به پیش نمونه اضافه شود تمامی اشیاء میتوانند به آن دسترسی پیدا کنند.</p> +```js +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 +``` + +<p dir='rtl'>پیش تر اشاره شد که __proto__ راه استانداردی برای دسترسی به پیش نمونه نیست و هیچ استانداردی نیز برای دسترسی به پیش نمونه ی یک شی موجود پیش بینی نشده است</p> +<p dir='rtl'>ولی دو راه برای ارائه پیش نمونه برای اشیاء جدید وجود دارد.</p> + +<p dir='rtl'>اولی وقتیست که از تابع Object.create استفاده میشود - که اخیرا به زبان اضافه شده است و بنابراین بر روی همه ی پیاده سازی های آن وجود ندارد.</p> +```js +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 +``` + + +<p dir='rtl'>راه دوم - که همه جا قابل استفاده است - مربوط به سازنده ها می شود.</p> +<p dir='rtl'>سازنده ها دارای عضوی با نام prototype هستند. این پیش نمونه ی خود سازنده نیست</p> +<p dir='rtl'>بلکه پیش نمونه ایست که به تمامی اشیاء ساخته شده توسط این سازنده الحاق میشود.</p> +```js +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function(){ + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 +``` + + +<p dir='rtl'>رشته ها و سایر سازنده های پیش ساخته ی زبان نیز دارای این ویژگی هستند.</p> +```js +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true +``` + + +<p dir='rtl'>به جز این که این سازنده ها دقیقا مانند سازنده های دیگر نیستند.</p> +```js +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0){ + // This code won't execute, because 0 is falsy. +} +``` + + +<p dir='rtl'>ولی به هر حال هم اشیاء عادی و هم اشیاء پیش ساخته هر دو در داشتن پیش نمونه مشترک هستند</p> +<p dir='rtl'>بنابر این شما میتوانید ویژگی و تابع جدیدی به رشته ها - به عنوان مثال - اضافه کنید.</p> + + +<p dir='rtl'>گاها به از این خاصیت با عنوان پلی فیل و برای اضافه کردن ویژگی های جدید به مجموعه ای از اشیاء فعلی زبان استفاده میشود </p> +<p dir='rtl'>که کاربرد فراوانی در پشتیبانی از نسخه های قدیمیتر مرورگر ها دارد.</p> +```js +String.prototype.firstCharacter = function(){ + return this.charAt(0); +} +"abc".firstCharacter(); // = "a" +``` + + +<p dir='rtl'>برای مثال، پیشتر اشاره کردیم که Object.create در نسخه های جدید پشتیبانی نشده است</p> +<p dir='rtl'>ولی میتوان آن را به صورت پلی فیل استفاده کرد.</p> +```js +if (Object.create === undefined){ // don't overwrite it if it exists + Object.create = function(proto){ + // make a temporary constructor with the right prototype + var Constructor = function(){}; + Constructor.prototype = proto; + // then use it to create a new, appropriately-prototyped object + return new Constructor(); + } +} +``` + +<h2 dir='rtl'> منابع دیگر </h2> + +The [Mozilla Developer +Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) +<p dir='rtl'>مرجعی بسیار خوب برای جاوااسکریپت به شکلی که در مرورگر ها مورد استفاده قرار گرفته است.</p> +<p dir='rtl'>از آنجایی که این منبع یک ویکی میباشد همانطور که مطالب بیشتری یاد میگیرید میتوانید به دیگران نیز در یادگیری آن کمک کنید.</p> + +MDN's [A re-introduction to +JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +<p dir='rtl'>مشابه مطالبی که اینجا مطرح شده با جزییات بیشتر. در اینجا به شکل عمدی جاوااسکریپت فقط از دیدگاه زبان برنامه نویسی مورد بررسی قرار گرفته</p> +<p dir='rtl'>در حالی که در این منبع میتوانید بیشتر از کاربرد آن در صفحات وب آشنایی پیدا کنید.</p> +[Document Object +Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Javascript Garden](http://bonsaiden.github.io/JavaScript-Garden/) +<p dir='rtl'>راهنمای دقیقی از قسمت های غیر ملموس زبان.</p> + +<p dir='rtl'>اضافه بر این در ویرایش این مقاله، قسمت هایی از سایت زیر مورد استفاده قرار گرفته است.</p> +Louie Dinh's Python tutorial on this site, and the [JS +Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +on the Mozilla Developer Network. diff --git a/forth.html.markdown b/forth.html.markdown new file mode 100644 index 00000000..f7c0bf34 --- /dev/null +++ b/forth.html.markdown @@ -0,0 +1,225 @@ +--- +language: forth +contributors: + - ["Horse M.D.", "http://github.com/HorseMD/"] +filename: learnforth.fs +--- + +Forth was created by Charles H. Moore in the 70s. It is an imperative, +stack-based language and programming environment, being used in projects +such as Open Firmware. It's also used by NASA. + +Note: This article focuses predominantly on the Gforth implementation of +Forth, but most of what is written here should work elsewhere. + +``` +\ This is a comment +( This is also a comment but it's only used when defining words ) + +\ --------------------------------- Precursor ---------------------------------- + +\ All programming in Forth is done by manipulating the parameter stack (more +\ commonly just referred to as "the stack"). +5 2 3 56 76 23 65 \ ok + +\ Those numbers get added to the stack, from left to right. +.s \ <7> 5 2 3 56 76 23 65 ok + +\ In Forth, everything is either a word or a number. + +\ ------------------------------ Basic Arithmetic ------------------------------ + +\ Arithmetic (in fact most words requiring data) works by manipulating data on +\ the stack. +5 4 + \ ok + +\ `.` pops the top result from the stack: +. \ 9 ok + +\ More examples of arithmetic: +6 7 * . \ 42 ok +1360 23 - . \ 1337 ok +12 12 / . \ 1 ok +13 2 mod . \ 1 ok + +99 negate . \ -99 ok +-99 abs . \ 99 ok +52 23 max . \ 52 ok +52 23 min . \ 23 ok + +\ ----------------------------- Stack Manipulation ----------------------------- + +\ Naturally, as we work with the stack, we'll want some useful methods: + +3 dup - \ duplicate the top item (1st now equals 2nd): 3 - 3 +2 5 swap / \ swap the top with the second element: 5 / 2 +6 4 5 rot .s \ rotate the top 3 elements: 4 5 6 +4 0 drop 2 / \ remove the top item (dont print to screen): 4 / 2 +1 2 3 nip .s \ remove the second item (similar to drop): 1 3 + +\ ---------------------- More Advanced Stack Manipulation ---------------------- + +1 2 3 4 tuck \ duplicate the top item into the second slot: 1 2 4 3 4 ok +1 2 3 4 over \ duplicate the second item to the top: 1 2 3 4 3 ok +1 2 3 4 2 roll \ *move* the item at that position to the top: 1 3 4 2 ok +1 2 3 4 2 pick \ *duplicate* the item at that position to the top: 1 2 3 4 2 ok + +\ When referring to stack indexes, they are zero-based. + +\ ------------------------------ Creating Words -------------------------------- + +\ The `:` word sets Forth into compile mode until it sees the `;` word. +: square ( n -- n ) dup * ; \ ok +5 square . \ 25 ok + +\ We can view what a word does too: +see square \ : square dup * ; ok + +\ -------------------------------- Conditionals -------------------------------- + +\ -1 == true, 0 == false. However, any non-zero value is usually treated as +\ being true: +42 42 = \ -1 ok +12 53 = \ 0 ok + +\ `if` is a compile-only word. `if` <stuff to do> `then` <rest of program>. +: ?>64 ( n -- n ) dup 64 > if ." Greater than 64!" then ; \ ok +100 ?>64 \ Greater than 64! ok + +\ Else: +: ?>64 ( n -- n ) dup 64 > if ." Greater than 64!" else ." Less than 64!" then ; +100 ?>64 \ Greater than 64! ok +20 ?>64 \ Less than 64! ok + +\ ------------------------------------ Loops ----------------------------------- + +\ `do` is also a compile-only word. +: myloop ( -- ) 5 0 do cr ." Hello!" loop ; \ ok +myloop +\ Hello! +\ Hello! +\ Hello! +\ Hello! +\ Hello! ok + +\ `do` expects two numbers on the stack: the end number and the start number. + +\ We can get the value of the index as we loop with `i`: +: one-to-12 ( -- ) 12 0 do i . loop ; \ ok +one-to-12 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok + +\ `?do` works similarly, except it will skip the loop if the end and start +\ numbers are equal. +: squares ( n -- ) 0 ?do i square . loop ; \ ok +10 squares \ 0 1 4 9 16 25 36 49 64 81 ok + +\ Change the "step" with `+loop`: +: threes ( n n -- ) ?do i . 3 +loop ; \ ok +15 0 threes \ 0 3 6 9 12 ok + +\ Indefinite loops with `begin` <stuff to do> <flag> `unil`: +: death ( -- ) begin ." Are we there yet?" 0 until ; \ ok + +\ ---------------------------- Variables and Memory ---------------------------- + +\ Use `variable` to declare `age` to be a variable. +variable age \ ok + +\ Then we write 21 to age with the word `!`. +21 age ! \ ok + +\ Finally we can print our variable using the "read" word `@`, which adds the +\ value to the stack, or use `?` that reads and prints it in one go. +age @ . \ 21 ok +age ? \ 21 ok + +\ Constants are quite simiar, except we don't bother with memory addresses: +100 constant WATER-BOILING-POINT \ ok +WATER-BOILING-POINT . \ 100 ok + +\ ----------------------------------- Arrays ----------------------------------- + +\ Creating arrays is similar to variables, except we need to allocate more +\ memory to them. + +\ You can use `2 cells allot` to create an array that's 3 cells long: +variable mynumbers 2 cells allot \ ok + +\ Initialize all the values to 0 +mynumbers 3 cells erase \ ok + +\ Alternatively we could use `fill`: +mynumbers 3 cells 0 fill + +\ or we can just skip all the above and initialize with specific values: +create mynumbers 64 , 9001 , 1337 , \ ok (the last `,` is important!) + +\ ...which is equivalent to: + +\ Manually writing values to each index: +64 mynumbers 0 cells + ! \ ok +9001 mynumbers 1 cells + ! \ ok +1337 mynumbers 2 cells + ! \ ok + +\ Reading values at certain array indexes: +0 cells mynumbers + ? \ 64 ok +1 cells mynumbers + ? \ 9001 ok + +\ We can simplify it a little by making a helper word for manipulating arrays: +: of-arr ( n n -- n ) cells + ; \ ok +mynumbers 2 of-arr ? \ 1337 ok + +\ Which we can use for writing too: +20 mynumbers 1 of-arr ! \ ok +mynumbers 1 of-arr ? \ 20 ok + +\ ------------------------------ The Return Stack ------------------------------ + +\ The return stack is used to the hold pointers to things when words are +\ executing other words, e.g. loops. + +\ We've already seen one use of it: `i`, which duplicates the top of the return +\ stack. `i` is equivalent to `r@`. +: myloop ( -- ) 5 0 do r@ . loop ; \ ok + +\ As well as reading, we can add to the return stack and remove from it: +5 6 4 >r swap r> .s \ 6 5 4 ok + +\ NOTE: Because Forth uses the return stack for word pointers, `>r` should +\ always be followed by `r>`. + +\ ------------------------- Floating Point Operations -------------------------- + +\ Most Forths tend to eschew the use of floating point operations. +8.3e 0.8e f+ f. \ 9.1 ok + +\ Usually we simply prepend words with 'f' when dealing with floats: +variable myfloatingvar \ ok +4.4e myfloatingvar f! \ ok +myfloatingvar f@ f. \ 4.4 ok + +\ --------------------------------- Final Notes -------------------------------- + +\ Typing a non-existent word will empty the stack. However, there's also a word +\ specifically for that: +clearstack + +\ Clear the screen: +page + +\ Loading Forth files: +\ s" forthfile.fs" included + +\ You can list every word that's in Forth's dictionary (but it's a huge list!): +\ words + +\ Exiting Gforth: +\ bye + +``` + +##Ready For More? + +* [Starting Forth](http://www.forth.com/starting-forth/) +* [Simple Forth](http://www.murphywong.net/hello/simple.htm) +* [Thinking Forth](http://thinking-forth.sourceforge.net/) diff --git a/fr-fr/bash-fr.html.markdown b/fr-fr/bash-fr.html.markdown new file mode 100644 index 00000000..0e764d7d --- /dev/null +++ b/fr-fr/bash-fr.html.markdown @@ -0,0 +1,230 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] +translators: + - ["Baptiste Fontaine", "http://bfontaine.net"] +filename: LearnBash-fr.sh +lang: fr-fr +--- + +Bash est le nom du shell UNIX, qui était aussi distribué avec le système +d’exploitation GNU et est le shell par défaut sur Linux et Mac OS X. + +Presque tous les exemples ci-dessous peuvent être écrits dans un script shell +ou exécutés directement dans le terminal. + +[Plus d’informations ici.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# La première ligne du script s’appelle le « shebang, » qui indique au système +# comment exécuter le script : http://fr.wikipedia.org/wiki/Shebang +# Comme vous pouvez le remarquer, les commentaires commencent par #. Le shebang +# est aussi un commentaire + +# Un exemple simple qui affiche « Hello world! » : +echo Hello world! + +# Chaque commande commence sur une nouvelle ligne ou après un point-virgule : +echo 'Ceci est la première ligne'; echo 'Ceci est la seconde ligne' + +# La déclaration d’une variable ressemble à ça : +VARIABLE="Du texte" + +# Mais pas comme ça : +VARIABLE = "Du texte" +# Bash va penser que VARIABLE est une commande qu’il doit exécuter et va +# afficher une erreur parce qu’elle est introuvable. + +# Utiliser une variable : +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Quand vous utilisez la variable en elle-même – en lui assignant une valeur, +# en l’exportant ou autre – vous écrivez son nom sans $. Si vous voulez +# utiliser sa valeur, vous devez utiliser $. +# Notez qu’entourer une variable de deux guillemets simples (') empêche +# l’expansion des variables ! + +# Substitution de chaîne de caractères dans une variable +echo ${VARIABLE/Some/A} +# Ceci va remplacer la première occurrence de « Some » par « A » + +# Sous-chaîne d’une variable +echo ${VARIABLE:0:7} +# Ceci va retourner seulement les 7 premiers caractères de la valeur + +# Valeur par défaut d’une variable +echo ${FOO:-"ValeurParDefautSiFOOestVideOuInexistant"} +# Ceci marche pour null (FOO=), la chaîne de caractères vide (FOO=""). Zéro +# (FOO=0) retourne 0 + +# Variables pré-remplies : +# Il y a quelques variables pré-remplies utiles, comme : +echo "La valeur de retour du dernier programme : $?" +echo "Le PID du script : $$" +echo "Nombre d’arguments : $#" +echo "Arguments du script : $@" +echo "Arguments du script séparés en plusieurs variables : $1 $2..." + +# Lire une valeur depuis l’entrée standard : +echo "Quel est votre nom ?" +read NAME # Notez que l’on n’a pas eu à déclarer une nouvelle variable +echo Bonjour, $NAME! + +# Nous avons l’habituelle structure « if » : +# Utilisez 'man test' pour plus d’informations à propos des conditions +if [ $NAME -ne $USER ] +then + echo "Votre nom n’est pas votre pseudo" +else + echo "Votre nom est votre pseudo" +fi + +# Il y a aussi l’exécution conditionnelle +echo "Toujours exécuté" || echo "Exécuté si la première commande ne réussit pas" +echo "Toujours exécuté" && echo "Exécuté si la première commande réussit" + +# Pour utiliser && et || avec des commandes « if, » vous devez utiliser +# plusieurs paires de crochets : +if [ $NAME == "Steve" ] && [ $AGE -eq 15 ] +then + echo "Ceci sera exécuté si $NAME est Steve ET $AGE est 15." +fi + +if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ] +then + echo "Ceci sera exécuté si $NAME est Daniya OU Zach." +fi + +# Les expressions sont écrites dans le format suivant : +echo $(( 10 + 5 )) + +# Contrairement aux autres langages de programmation, Bash est un shell — il +# est donc exécuté dans le contexte du répertoire courant. Vous pouvez lister +# les fichiers et dossiers dans le répertoire courant avec la commande `ls` : +ls + +# Ces commandes ont des options qui contrôlent leur exécution : +ls -l # Liste tous les fichiers et répertoires sur des lignes séparées + +# Les résultat de la commande précédente peuvent être passés à la commande +# suivante en entrée. +# La commande grep filtre l’entrée avec les motifs donnés. On peut ainsi lister +# les fichiers .txt dans le répertoire courant : +ls -l | grep "\.txt" + +# Vous pouvez aussi rediriger l’entrée et les sorties standards et d’erreur +# d’une commande : +python2 hello.py < "entrée.in" +python2 hello.py > "sortie.out" +python2 hello.py 2> "erreur.err" +# Ceci va écraser le fichier s'il existe; si vous préférez écrire à la fin de +# celui-ci, utilisez >> à la place. + +# Les commandes peuvent se substituer à l’intérieur d’autres commandes en +# utilisant $( ) : +# La commande ci-dessous affiche le nombre de fichiers et répertoires dans le +# répertoire courant : +echo "Il y a $(ls | wc -l) choses ici." + +# On peut faire la même chose avec les accents graves `` mais on ne peut pas +# les imbriquer — la façon la plus courante est d’utiliser $( ). +echo "There are `ls | wc -l` items here." + +# Bash a une commande case qui marche de façon similaire au switch de Java et +# C++ : +case "$VARIABLE" in + #List patterns for the conditions you want to meet + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# La boucle for itère autant de fois qu’elle a d’arguments : +# Le contenu de $VARIABLE est affiché trois fois. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# Ou écrivez-la de façon « traditionnelle » : +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Elles peuvent aussi être utilisées pour agir sur des fichiers : +# Cette boucle va exécuter la commande 'cat' sur fichier1 et fichier2 +for VARIABLE in fichier1 fichier2 +do + cat "$VARIABLE" +done + +# …ou la sortie d’une commande : +# Ceci va afficher la sortie de ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# Boucle while : +while [ true ] +do + echo "corps de la boucle ..." + break +done + +# Vous pouvez aussi définir des fonctions +# Définition : +function foo () +{ + echo "Les arguments fonctionnent comme les arguments de script : $@" + echo "Et : $1 $2..." + echo "Ceci est une fonction" + return 0 +} + +# Ou plus simplement : +bar () +{ + echo "Une autre façon de définir des fonctions !" + return 0 +} + +# Appeler votre fonction +foo "Mon nom est" $NAME + +# Il y a plein de commandes utiles que vous devriez apprendre : +# affiche les 10 dernières lignes de fichier.txt +tail -n 10 fichier.txt +# affiche les 10 premières lignes de fichier.txt +head -n 10 fichier.txt +# trie les lignes de fichier.txt +sort fichier.txt +# montre ou omet les lignes répétées, avec -d pour les montrer +uniq -d fichier.txt +# affiche uniquement la première colonne avant le caractère « , » +cut -d ',' -f 1 fichier.txt +# remplace chaque occurrence de 'okay' par 'super' dans fichier.txt +# (compatible avec les expression rationnelles) +sed -i 's/okay/super/g' fichier.txt +# affiche toutes les lignes de fichier.txt qui correspondent à une expression +# rationnelle, dans cet exemple les lignes qui commencent par « foo » et +# finissent par « bar » +grep "^foo.*bar$" fichier.txt +# ajoutez l’option « -c » pour afficher le nombre de lignes concernées +grep -c "^foo.*bar$" fichier.txt +# Si vous voulez vraiment chercher une chaîne de caractères, et non +# l’expression rationnelle, utilisez fgrep (ou grep -F) +fgrep "^foo.*bar$" fichier.txt +``` diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown new file mode 100644 index 00000000..545e407e --- /dev/null +++ b/fr-fr/brainfuck-fr.html.markdown @@ -0,0 +1,87 @@ +--- +language: brainfuck +filename: learnbrainfuck-fr.bf +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Baptiste Fontaine", "http://bfontaine.net"] +lang: fr-fr +--- + +Brainfuck (sans majuscule à part au début d’une phrase) est un langage +Turing-complet extrêmement simple avec seulement 8 commandes. + +``` +Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré. + +Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et +un pointeur de données pointant sur la cellule courante. + +Il y a huit commandes : ++ : Incrémente la valeur de la cellule courante de un. +- : Décrémente la valeur de la cellule courante de un. +> : Déplace le pointeur de données sur la cellule suivante (à droite). +< : Déplace le pointeur de données sur la cellule précédente (à gauche). +. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A'). +, : Lit un caractère et le place dans la cellule courante. +[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant. + Sinon, continue avec la commande suivante. +] : Si la valeur dans la cellule courante vaut 0, continue avec la commande + suivante. Sinon, retourne au [ correspondant. + +[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment +aller par paires. + +Regardons quelques programmes simples en brainfuck. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Ce programme affiche la lettre 'A'. Il commence par incrémenter la première +cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde +cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la +décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6 +décrémentations de la première cellule pour la faire atteindre 0, ce qui fait +sortir de la boucle). + +À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0, +tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur +celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur. +En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal. + +, [ > + < - ] > . + +Ce programme lit un caractère sur l’entrée standard et le copie dans la +première cellule. Il commence ensuite une boucle : il bouge sur la seconde +cellule, incrémente sa valeur, retourne sur la première et décrémente sa +valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0, +et que la seconde cellule contienne l’ancienne valeur de la première. Comme +nous sommes sur la première cellule à la fin de la boucle, il bouge sur la +seconde et affiche sa valeur en ASCII. + +Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité, +vous pourriez tout aussi aisément écrire le programme comme ceci : + +,[>+<-]>. + +Essayez et devinez ce que ce programme fait : + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Ce programme prend deux nombres en entrée, et les multiplie. + +Il commence par lire deux entrées, puis commence une boucle externe, qui a une +condition sur la première cellule. Il bouge ensuite sur la seconde, et commence +une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a +cependant un problème : à la fin de la boucle interne, la valeur de la seconde +cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une +seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième +cellule, puis recopions sa valeur dans la seconde cellule. +À la fin, la troisième cellule contient le résultat de la multiplication. +``` + +Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez +écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck +dans un autre langage. L’interpréteur est relativement simple à implémenter, +mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en… +brainfuck. diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown new file mode 100644 index 00000000..d3c5a67b --- /dev/null +++ b/fr-fr/clojure-fr.html.markdown @@ -0,0 +1,398 @@ +--- +language: clojure +filename: learnclojure-fr.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Bastien Guerry", "https://github.com/bzg"] +lang: fr-fr +--- + +Clojure est un langage de la famille des Lisp développé pour la machine +virtuelle Java. Ce langage insiste beaucoup plus sur la [programmation +fonctionnelle](https://fr.wikipedia.org/wiki/Programmation_fonctionnelle) pure +que Common Lisp, mais comprend plusieurs outils de gestion de la mémoire +transactionnelle +[STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pour gérer +les changements d'états si besoin. + +Cette combinaison permet de gérer le parallélisme très simplement, et +souvent de façon automatique. + +(Vous avez besoin de Clojure 1.2 ou plus récent pour ce tutoriel.) + +```clojure +; Les commentaires commencent avec un point-virgule. + +; Clojure est composé de « formes », qui sont simplement des listes +; d'expressions entre parenthèses, séparées par une ou des espaces. +; +; L'interpréteur Clojure suppose que le premier élément est une fonction +; ou une macro, et que le reste contient des arguments. + +; Le premier appel dans un fichier doit être ns, pour définir +; l'espace de nom +(ns learnclojure) + +; D'autres d'exemples basiques: + +; str va créer une chaîne de caractères à partir de tous ses arguments +(str "Hello" " " "World") ; => "Hello World" + +; Les opérations mathématiques sont simples +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; L'égalité est = +(= 1 1) ; => true +(= 2 1) ; => false + +; Vous avez aussi besoin de not pour la négation logique +(not true) ; => false + +; Les formes imbriquées fonctionnent comme on s'y attend +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; Types +;;;;;;;;;;;;; + +; Clojure utilise les types d'objets Java pour les booléens, les chaînes de +; caractères et les nombres. +; Utilisez `class` pour inspecter les types. +(class 1) ; Les nombres entiers littéraux sont java.lang.Long par défaut +(class 1.); Les flottants littéraux sont java.lang.Double +(class ""); Les chaînes sont toujours entourées de guillemets doubles, et sont java.lang.String +(class false) ; Les booléens sont java.lang.Boolean +(class nil); La valeur "null" est appelée nil + +; Si vous voulez créer une liste littérale de données, utilisez ' pour en +; empêcher son évaluation +'(+ 1 2) ; => (+ 1 2) +; (qui est un raccourci pour (quote (+ 1 2))) + +; Vous pouvez évaluer une liste "quotée": +(eval '(+ 1 2)) ; => 3 + +; Collections & séquences +;;;;;;;;;;;;;;;;;;;;;;;;; + +; Les listes sont des structures de données en listes chaînées, alors que les +; vecteurs reposent sur des tableaux. +; Les vecteurs et les listes sont des classes Java aussi ! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; Une liste serait écrite comme (1 2 3), mais nous devons la quoter +; pour empêcher l'interpréteur de penser que c'est une fonction. +; Et (list 1 2 3) est la même chose que '(1 2 3) + +; Les "Collections" sont juste des groupes de données +; Les listes et les vecteurs sont tous deux des collections: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; Les "séquences" (seqs) sont des abstractions à partir de listes de données. +; Seules les listes sont elles-mêmes des séquences. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; Une séquence n'a besoin de fournir une entrée que lorsqu'on y accède. +; Donc, les séquences peuvent être "lazy" -- et définir une série infinie: +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (une série infinie) +(take 4 (range)) ; (0 1 2 3) + +; Utilisez cons pour ajouter un item au début d'une liste ou d'un vecteur +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; Conj ajoutera un item à une collection de la manière la plus efficace +; Pour les listes, conj ajoute l'item au début; pour les vecteurs, à la fin. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; Utilisez concat pour ajouter des listes ou vecteurs: +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; Utilisez filter, map pour interagir avec des collections +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; Utilisez reduce pour les réduire +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; Reduce peut aussi prendre un argument pour la valeur initiale +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; Fonctions +;;;;;;;;;;;;;;;;;;;;; + +; Utilisez fn pour créer de nouvelles fonctions. +; Une fonction renvoie toujours sa dernière expression. +(fn [] "Hello World") ; => fn + +; (Vous devez ajouter des parenthèses pour l'appeler) +((fn [] "Hello World")) ; => "Hello World" + +; Vous pouvez créer une variable en utilisant def +(def x 1) +x ; => 1 + +; Assignez une fonction à une variable +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; Vous pouvez raccourcir le procédé en utilisant defn +(defn hello-world [] "Hello World") + +; [] contient la liste des arguments de la fonction +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; Vous pouvez aussi utiliser ce raccourci pour créer des fonctions +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; Vous pouvez avoir des fonctions multi-variadiques +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; Les fonctions peuvent inclure des arguments supplémentaires dans une séquence +(defn count-args [& args] + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "Vous avez passé 3 args: (1 2 3)" + +; Vous pouvez combiner les arguments normaux et supplémentaires +(defn hello-count [name & args] + (str "Hello " name ", vous avez passé " (count args) " args supplémentaires")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, vous avez passé 3 args supplémentaires" + + +; Maps +;;;;;;;;;;;;;;; + +; Les hashmaps et les arraymaps partagent une interface. Les hashmaps +; sont interrogés plus rapidement mais ne retiennent pas l'ordre des clefs. +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; Les array maps deviennent automatiquement des hashmaps pour la +; plupart des opérations si elles deviennent assez larges, donc vous +; n'avez pas à vous en faire. + +; Tous les types "hashables" sont acceptés comme clefs, mais en +; général on utilise des mots-clefs ("keywords") +; Les mots-clefs sont comme les chaînes de caractères mais en plus efficaces +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; Au passage, les virgules sont toujours traitées comme des espaces et +; ne font rien. + +; Sélectionnez une valeur dans une map en l'appelant comme fonction +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; Les mots-clefs peuvent aussi être utilisés pour sélectionner leur +; valeur dans une map ! +(:b keymap) ; => 2 + +; N'essayez pas ça avec les chaînes de caractères +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; Sélectionner une clef absente renvoie nil +(stringmap "d") ; => nil + +; Use assoc to add new keys to hash-maps +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; Mais souvenez-vous, les types en Clojure sont immuables ! +keymap ; => {:a 1, :b 2, :c 3} + +; Utilisez dissoc pour retirer des clefs +(dissoc keymap :a :b) ; => {:c 3} + +; Ensembles +;;;;;;;;;;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; Ajoutez un élément avec conj +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; Retirez-en un avec disj +(disj #{1 2 3} 1) ; => #{2 3} + +; Testez la présence en utilisant l'ensemble comme une fonction +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; Il y a encore d'autres fonctions dans l'espace de nom clojure.sets. + +; Formes utiles +;;;;;;;;;;;;;;; + +; Les constructions logiques en Clojure sont juste des macros, et +ressemblent à toutes les autres formes: +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; Utilisez let pour créer des assignations temporaires +(let [a 1 b 2] + (> a b)) ; => false + +; Groupez les énoncés ensemble avec do +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; Les fonctions ont un do implicit +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; De même pour let +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; Modules +;;;;;;;;;;;;;;; + +; Utilisez "use" pour obtenir toutes les fonctions d'un module +(use 'clojure.set) + +; Maintenant nous pouvons utiliser les opération de set +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; Vous pouvez aussi choisir un sous-ensemble de fonctions à importer +(use '[clojure.set :only [intersection]]) + +; Utilisez require pour importer un module +(require 'clojure.string) + +; Utilisez / pour appeler les fonctions d'un module +; Ici, le module est clojure.string et la fonction est blank? +(clojure.string/blank? "") ; => true + +; Vous pouvez associer un nom plus court au module au moment de l'importer +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (#"" dénote une expression régulière) + +; Vous pouvez utiliser require (et use, mais ne le faites pas) en +; appelant :require depuis un espace de noms. +; Dans ce cas-là, vous n'avez pas besoin de "quoter" vos modules: +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java a une librairie standard énorme, donc vous voudrez apprendre à +; vous familiariser avec. + +; Utilisez import pour charger un module java +(import java.util.Date) + +; Vous pouvez importer depuis un ns aussi. +(ns test + (:import java.util.Date + java.util.Calendar)) + +; Utilisez les noms de classes avec "." à la fin pour créer une instance +(Date.) ; <un objet date> + +; Utilisez . pour invoquer des méthodes. Ou utilisez le raccourci ".method" +(. (Date.) getTime) ; <un timestamp> +(.getTime (Date.)) ; exactement la même chose + +; Utilisez / pour appeler des méthodes statiques +(System/currentTimeMillis) ; <un timestamp> (system est toujours présent) + +; Utilisez doto to rendre plus tolérable l'interaction avec des +; classes (mutables) +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => Une classe Date. définie comme 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; La mémoire logiciel transactionnelle ("Software Transactional Memory") +; est le mécanisme que Clojure utilise pour gérer les états persistents. +; Il y a plusieurs formes en Clojure qui utilisent cela. + +; L'atome est la plus simple. Passez-lui une valeur initiale +(def my-atom (atom {})) + +; Mettez à jour un atome avec swap!. +; swap! prend une fonction en argument et l'appelle avec la valeur +; actuelle de l'atome comme premier argument, et les autres arguments +; comme second argument. +(swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2) + +; Use '@' to dereference the atom and get the value +my-atom ;=> Atom<#...> (Renvoie l'objet Atom) +@my-atom ; => {:a 1 :b 2} + +; Voici un simple compteur utilisant un atome +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; Les autres formes STM sont les refs et les agents. +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### Lectures complémentaires + +C'est loin d'être exhaustif, mais assez pour vous permettre de continuer. + +Clojure.org propose de nombreux articles: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org a de la documentation avec des exemples pour la +plupart des fonctions principales : +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure est une super manière d'augmenter vos compétences en Clojure et +en programmation fonctionnelle : +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org a pas mal d'article pour débuter : +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/fr-fr/coffeescript-fr.html.markdown b/fr-fr/coffeescript-fr.html.markdown new file mode 100644 index 00000000..c66b7be0 --- /dev/null +++ b/fr-fr/coffeescript-fr.html.markdown @@ -0,0 +1,58 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +translators: + - ["Geoffrey Roguelon", "https://github.com/GRoguelon"] +lang: fr-fr +filename: coffeescript-fr.coffee +--- + +``` coffeescript +# CoffeeScript est un langage préprocesseur, il permet de générer du Javascript. +# Il suit les tendances de certains langages récents. +# Par exemple, les commentaires se définissent comme en Ruby ou en Python. + +### +Ceci est un bloc de commentaires +il est converti directement avec '/ *' et '* /' +pour correspondre aux commentaires Javascript + +Vous devez comprendre la syntaxe du langage JavaScript pour continuer. +### + +# Affectation : +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# Structures de contrôle : +number = -42 if opposite #=> if(opposite) { number = -42; } + +# Fonctions : +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +# Intervals : +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# Objets : +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Liste d'arguments variables : +race = (winner, runners...) -> + print winner, runners + +# Existance : +alert "I knew it!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# Lecture d'un tableau : +cubes = (math.cube num for num in list) #=> ... +``` diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown new file mode 100644 index 00000000..58b3f386 --- /dev/null +++ b/fr-fr/csharp-fr.html.markdown @@ -0,0 +1,813 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] + - ["Melvyn Laïly", "http://x2a.yt"] + - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] +translators: + - ["Olivier Hoarau", "https://github.com/Olwaro"] +filename: LearnCSharp-fr.cs +lang: fr-fr +--- + +C# est un langage de programmation orienté objet à typage fort qui permet aux développeurs de créer une grande variété d'applications fiables et robustes s'appuyant sur le framework .NET. + +[Plus d'infos](http://msdn.microsoft.com/fr-fr/library/67ef8sbd.aspx) + +```c# +// Les commentaires sur une seule ligne commencent par // +/* +Les +commentaires +multi-lignes +ressemblent +à +ceci +*/ +/// <summary> +/// Ceci est un commentaire de documentation XML +/// </summary> + +// Importez des namespaces avec l'instruction 'using' +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Dynamic; +using System.Linq; +using System.Linq.Expressions; +using System.Net; +using System.Threading.Tasks; + +// Définit la portée du code pour une meilleure organisation +namespace Learning +{ + // Chaque fichier .cs devrait au moins contenir une classe avec le même nom + // que celui du fichier. Ce n'est pas une obligation mais c'est mieux ! + public class LearnCSharp + { + // LES BASES - si vous avez déjà de l'expérience en Java ou C++ + // passez directement à la partie FONCTIONNALITÉS INTERÉSSANTES + public static void Syntax() + { + // Utilisez Console.WriteLine pour écrire sur la sortie + Console.WriteLine("Hello World"); + Console.WriteLine( + "Entier: " + 10 + + " Double: " + 3.14 + + " Booleen: " + true); + + // Pour omettre le retour à la ligne : Console.Write + Console.Write("Hello "); + Console.Write("World"); + + /////////////////////////////////////////////////// + // Types et Variables + // Déclarez une variable avec la syntaxe <type> <nom> + /////////////////////////////////////////////////// + + // Sbyte - Entier signé sur 8 bits + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Entier non-signé sur 8 bits + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - Entier sur 16 bits + // Signé - (-32,768 <= short <= 32,767) + // Non-signé - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Int - Entier sur 32 bits + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - Entier sur 64 bits + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // Par défaut le type d'un littéral entier est int ou uint + // on ajoute 'L' pour spécifier la création d'un long + + // Double - Réel sur 64 bits en virgule flottante (norme IEEE 754) + double fooDouble = 123.4; // Precision : 15-16 chiffres + + // Float - Réel sur 32 bits en virgule flottante (norme IEEE 754) + float fooFloat = 234.5f; // Precision : 7 chiffres + // Par défaut le type d'un littéral réel est double + // on ajoute 'f' pour spécifier la création d'un float + + // Decimal - Type de donnée numérique sur 128 bits, fournit une plus + // grande précision et une plage de valeurs réduite. + // Approprié aux calculs financiers et monétaires + decimal fooDecimal = 150.3m; + + // Booléen - vrai / faux + bool fooBoolean = true; // ou false + + // Char - Un unique caractère Unicode sur 16 bits + char fooChar = 'A'; + + // String -- contrairement aux types précédents qui sont des types valeurs, + // string est un type référence. Il peut donc avoir la valeur null + string fooString = "\"échappement\" de guillemets et ajout de \n (nouvelle ligne) et de \t (tabulation)"; + Console.WriteLine(fooString); + + // Il est possible d'accéder à chaque caractère d'une chaîne de caractères via son index + char charFromString = fooString[1]; // 'é' + // une chaîne de caractères est immuable : impossible de faire fooString[1] = 'X'; + + // Comparaison de chaînes de caractères avec la culture courrante en ignorant la casse + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // Formatage + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // Dates et formatage + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // Il est possible d'étaler une chaîne de caractères sur plusieurs lignes avec le symbole @. + // Pour échapper " utilisez "" + string bazString = @"Voici quelques trucs +sur une nouvelle ligne! ""Wow!"", quel style"; + + // Utilisez const ou read-only pour rendre une variable immuable. + // Les valeurs constantes sont calculées au moment de la compilation + const int HOURS_I_WORK_PER_WEEK = 9001; + + /////////////////////////////////////////////////// + // Structures de données + /////////////////////////////////////////////////// + + // Tableaux - indexé à partir de zéro + // La taille d'un tableau doit être décidée à la déclaration + // La syntaxe pour déclarer un tableau est la suivante : + // <type>[] <nom> = new <type>[<taille>] + int[] intArray = new int[10]; + + // Une autre méthode de déclaration et d'initialisation + int[] y = { 9000, 1000, 1337 }; + + // Indexer un tableau - Accéder à un élément + Console.WriteLine("intArray à 0: " + intArray[0]); + // Les tableaux sont muables. + intArray[1] = 1; + + // Listes + // Elles sont plus souvent utilisées que les tableaux car plus souples + // La syntaxe pour déclarer une liste est la suivante : + // List<type> <nom> = new List<type>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // intialisation + // Les <> indiquent un type générique + // Pus d'info dans la partie FONCTIONNALITÉS INTERÉSSANTES + + // Les éléments d'une liste ne sont pas null par défaut + // Il faut ajouter une valeur avant d'y accéder par index + intList.Add(1); + Console.WriteLine("intList à 0: " + intList[0]); + + // Autres structures de données à étudier : + // Stack/Queue (Pile/File) + // Dictionary (une implémentation de hash map) + // HashSet (représente un ensemble) + // Collections en lecture seule + // Tuple (.Net 4+) + + /////////////////////////////////////// + // Opérateurs + /////////////////////////////////////// + Console.WriteLine("\n->Opérateurs"); + + int i1 = 1, i2 = 2; // Raccourci pour des déclarations multiples + + // Arithmétique classique + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // Modulo + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Opérateurs de comparaison + Console.WriteLine("3 == 2? " + (3 == 2)); // => False + Console.WriteLine("3 != 2? " + (3 != 2)); // => True + Console.WriteLine("3 > 2? " + (3 > 2)); // => True + Console.WriteLine("3 < 2? " + (3 < 2)); // => False + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => True + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => True + + // Opérateurs bit à bit ! + /* + ~ Compément unaire + << Décalage à gauche + >> Décalage à droite + & ET logique + ^ OU exclusif + | OU inclusif + */ + + // Incrémentations + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. Post-Incrémentation + Console.WriteLine(++i); //i = 2. Pre-Incrémentation + Console.WriteLine(i--); //i = 1. Post-Decrémentation + Console.WriteLine(--i); //i = 0. Pre-Decrémentation + + /////////////////////////////////////// + // Structures de contrôle + /////////////////////////////////////// + Console.WriteLine("\n->Structures de contrôle"); + + // Structure conditionnelle + int j = 10; + if (j == 10) + { + Console.WriteLine("Je serai affiché"); + } + else if (j > 10) + { + Console.WriteLine("Pas moi"); + } + else + { + Console.WriteLine("Moi non plus"); + } + + // Opérateur ternaire + // Un simple if/else peut s'écrire : + // <condition> ? <valeur si true> : <valeur si false> + int toCompare = 17; + string isTrue = toCompare == 17 ? "True" : "False"; + + // Boucle while + int fooWhile = 0; + while (fooWhile < 100) + { + // 100 passages, de 0 à 99 + fooWhile++; + } + + // Boucle Do While + int fooDoWhile = 0; + do + { + // 100 passages, de 0 à 99 + fooDoWhile++; + } while (fooDoWhile < 100); + + // Boucle for + // Structure : for(<etat_initial>; <condition>; <pas>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + // 10 passages, de 0 à 9 + } + + // La boucle foreach + // Structure : foreach(<type_iterateur> <nom_iterateur> in <enumerable>) + // Cette boucle est utilisable sur des objets implémentant IEnumerable ou IEnumerable<T> + // Toutes les collections du framework .NET (Tableaux, Listes, ...) implémentent ces interfaces. + // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car + // string implémente IEnumerable) + foreach (char character in "Hello World".ToCharArray()) + { + //Itération sur chaque caractère + } + + // La structure Switch Case + // Un switch fonctionne avec les types : byte, short, char et int. + // Les enums sont aussi supportés ainsi que les chaînes de caractères et quelques + // classes spéciales basées sur les types primitifs : Character, Byte, Short et Integer. + int mois = 3; + string moisString; + switch (mois) + { + case 1: + moisString = "Janvier"; + break; + case 2: + moisString = "Février"; + break; + case 3: + moisString = "Mars"; + break; + + // Vous pouvez assigner plus d'un 'case' à une action + // Mais vous ne pouvez pas ajouter une action sans 'break' avant un 'case' + // (pour ce faire, il faudrait ajouter explicitement un 'goto case x') + case 6: + case 7: + case 8: + moisString = "C'est l'été!"; + break; + default: + moisString = "Un autre mois oO"; + break; + } + + /////////////////////////////////////// + // conversion de type de donnée et transtypage + /////////////////////////////////////// + + // conversion de string vers int + // lève une exception en cas d'erreur + int.Parse("123"); //retourne la valeur entière de "123" + + // TryParse affecte la valeur par défaut du type en cas d'erreur + // dans ce cas : 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // La fonction retourne un booléen + Console.WriteLine(tryInt); // => 123 + + // conversion d'un entier vers une chaîne de caractères + // La classe Convert possède plusieurs méthodes pour faciliter la conversion + Convert.ToString(123); + // ou + tryInt.ToString(); + } + + /////////////////////////////////////// + // CLASSES - voir les définitions à la fin du fichier + /////////////////////////////////////// + + public static void Classes() + { + // voir les déclarations à la fin du fichier + + // Utilisez 'new' pour instancier une classe + Bicycle trek = new Bicycle(); + + // Appel des méthodes de l'objet + trek.SpeedUp(3); // Il est toujours bon d'utiliser des accesseurs + trek.Cadence = 100; + + // Affichage de la valeur de retour d'une méthode. + Console.WriteLine("trek info: " + trek.Info()); + + // Instanciation d'un nouveau PennyFarthing + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } + + // POINT D'ENTRÉE - Une application console doit avoir une méthode main comme point d'entrée + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // FONCTIONNALITÉS INTÉRÉSSANTES + // + + // SIGNATURE DE METHODE + public // Visibilité + static // Permet un appel direct par la classe (sans instanciation) + int // Type de retour, + MethodSignatures( + int maxCount, // Premier paramètre, de type int + int count = 0, // Valeur par défaut si aucun argument n'est passé + int another = 3, + params string[] otherParams // Capture tous les arguments passés à la méthode + ) + { + return -1; + } + + // Des méthodes peuvent avoir le même nom tant que leur signature est unique + public static void MethodSignature(string maxCount) + { + } + + // TYPE GÉNÉRIQUE + + // Les types TKey et TValue sont spécifiés par l'utilisateur lors de l'appel de la fonction + // Cette méthode émule SetDefaut de Python + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // Vous pouvez limiter les types autorisés + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // Nous sommes sûrs de pouvoir itérer, car T implémente IEnumerable<int> + foreach (var item in toPrint) + // Item sera de type int + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // PARAMÈTERES OPTIONNELS + MethodSignatures(3, 1, 3, "Des", "Paramètres", "En plus"); + MethodSignatures(3, another: 3); // affectation explicite, les autres + // paramètres ont la valeur par défaut + + // MÉTHODE D'EXTENSION + int i = 3; + i.Print(); // Définit plus bas + + // TYPES NULLABLE - idéal pour les interactions avec une base de données ou pour les valeurs de retour + // Tous les types valeurs peuvent être rendus nullable en les suffixant par '?' + // <type>? <nom> = <value> + int? nullable = null; // raccourci pour Nullable<int> + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // retourne vrai si la valeur n'est pas null + + // ?? est un sucre syntaxique pour spécifier une valeur par défaut + // au cas ou une autre valeur serait nulle + int notNullable = nullable ?? 0; // 0 + + // VARIABLES IMPLICITEMENT TYPÉES - vous pouvez laisser le compilateur deviner le type d'une variable + var magic = "magic est de type string à la compilation. On a toujours un typage fort !"; + // magic = 9; // ne fonctionnera pas car magic est désormais une chaîne de caractères + + // TYPES GÉNÉRIQUES + var agenda = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // Ajout d'une entrée à notre agenda + }; + + // Appel de la fonction SetDefault (définie plus haut) + Console.WriteLine(SetDefault<string,string>(agenda, "Shaun", "Pas de numéro")); // => Pas de numéro + // Notez que vous n'avez pas à spécifier TKey et TValue car le compilateur saura les inférer. + Console.WriteLine(SetDefault(agenda, "Sarah", "No Phone")); // => 212 555 5555 + + // EXPRESSION LAMBDA - permet d'écrire une fonction en tant qu'expression + Func<int, int> square = (x) => x * x; // La dernière expression est la valeur de retour + Console.WriteLine(square(3)); // => 9 + + // GESTION AUTOMATIQUE DES RESSOURCES - vous permet de manipuler facilement des resources non-managées + // La plus part des objets qui accèdent à des ressources non-managées (handle de fichier, périphérique, etc.) + // implémentent l'interface IDisposable. L'instruction using prend soin + // de libérer les objets IDisposable proprement à votre place. + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("Rien à signaler"); + // À la fin de cette portée les ressources seront libérées. + // Même si une exception est levée. + } + + // BIBLIOTHÈQUE DE TÂCHES PARALLÈLES (TPL) + // http://msdn.microsoft.com/fr-fr/library/dd460717.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // L'exemple suivant exécutera chaque requête dans un thread séparé, + // et attendra la fin de chacun d'entre eux avant de continuer + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // maximum de 3 threads + website => + { + // Fait quelque chose de long + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // Ceci ne s'exécutera pas tant que les threads n'auront pas fini leur travail + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // TYPE DYNAMIQUE - idéal pour travailler avec d'autres langages + dynamic student = new ExpandoObject(); + student.FirstName = "Mon prénom"; // Pas besoin de définir l'objet + + // Vous pouvez même ajouter des méthodes (dans cet exemple : la méthode prend une chaîne de caractères et retourne une chaîne de caractères) + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, c'est {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - quasiment toutes les collections implémentent cette interface + // ce qui permet d'utiliser des méthodes de style 'Filter' / 'Map' / 'Reduce' + var bikes = new List<Bicycle>(); + bikes.Sort(); // Trie le tableau sur place + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Trie en se basant sur la propriété Wheels + var result = bikes + .Where(b => b.Wheels > 3) // 'Filter' - enchaînable (retourne un IQueryable du type précédent) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // 'Map' - on retourne le .ToString() de chaque élément filtré, + // le résultat est un IQueryable<string> + + var sum = bikes.Sum(b => b.Wheels); // 'Reduce' - fait la somme de tous les Wheels de la liste + + // Creation d'une liste d'objet anonymes basés sur des paramètres de la classe Bike + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // Le compilateur peut inférer le type de ces objets anonymes, permettant à certains IDE d'effectuer + // des autos-complétion. + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + + // ASPARALLEL + // C'est ici que les choses se compliquent - un mélange de LINQ et de TPL + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // La ligne précédente s'exécute en parallèle ! Des threads seront gérés automatiquement + // et les données y seront réparties. Idéal sur de grosses données (et si votre + // machine dispose de plusieurs coeurs) + + + // LINQ - lie une source de données à des objets IQueryable<T> + // ex : LindToSql => liaison avec une base de données, LinqToXml => liaison avec un document xml + var db = new BikeRespository(); + + // l'exécution est décalée, ce qui est préférable quand on travaille sur une base données + var filter = db.Bikes.Where(b => b.HasTassles); // pas de requête exécutée + if (42 > 6) // Vous pouvez continuer à affiner la recherche + filter = filter.Where(b => b.IsBroken); // pas de requête exécutée + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // toujours pas de requête exécutée + + // Maintenant la requête est exécutée, mais retourne des données uniquement au fil de l'itération + foreach (string bike in query) + Console.WriteLine(result); + + } + + } // Fin de la classe LearnCSharp + + // Il est possible d'inclure plusieurs classes dans un fichier .cs + + public static class Extensions + { + // EXTENSION DE FONCTIONS + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + + // Syntaxe de déclaration de classe : + // <public/private/protected/internal> class <class name>{ + // // champs, constructeurs, fonctions + // // tout est déclaré et implémenté à l'intérieur + // } + + public class Bicycle + { + // Propriétés et variable de la classe + public int Cadence // Public : peut être accédé de partout + { + get // get - définit une méthode pour lire la propriété + { + return _cadence; + } + set // set - définit une méthode pour affecter une valeur à la propriété + { + _cadence = value; // 'value' est la valeur passée en argument au setteur + } + } + private int _cadence; + + protected virtual int Gear // Protected : accessible depuis la classe et ses classes filles + { + get; // crée une propriété automatique, pas besoin de créer une variable de stockage + set; + } + + internal int Wheels // Internal : accessible depuis l'assembly + { + get; + private set; // Il est possible de choisir la portée d'un accesseur + } + + int _speed; // Par défaut tout est privé au sein d'une classe : accessible uniquement depuis la classe + // on peut ajouter explicitement le mot clé 'private' + + public string Name { get; set; } + + + // Enum est un type valeur formé par un ensemble de constantes nommées + // C'est simplement une manière de mettre un nom sur une valeur (int par défaut). + // Les types compatibles pour un enum sont : byte, sbyte, short, ushort, int, uint, long et ulong. + // Un enum ne peut pas contenir deux fois la même valeur + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, // il est possible de donner explicitement une valeur + Gitane // 43 + } + // Nous avons défini cet enum à l'intérieur de la classe Bicycle, c'est donc un type imbriqué + // Pour le référencer à l'extérieur, il faudra utiliser Bicycle.BikeBrand + + public BikeBrand Brand; // Après avoir déclaré notre type enum, on peut créer un champ de ce type + + // Les membres statiques appartiennent à une classe plutôt qu'à une instance particulière + // Il est possible d'y accéder sans passer par un objet : + // ex : Console.WriteLine("Bicycles créés : " + Bicycle.bicyclesCreated); + static public int BicyclesCreated = 0; + + // Les valeurs en lecture seule sont affectées lors de l'exécution + // Elles ne peuvent être assignées que lors de leur déclaration ou dans un constructeur + readonly bool _hasCardsInSpokes = false; // variable en lecture et privée + + // Les constructeurs sont un moyen de créer des objets + // Voici un constructeur par défaut (pas d'arguments) + public Bicycle() + { + this.Gear = 1; // accès aux membres de la classe via le mot clé this + Cadence = 50; // qui est souvent implicite + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // Voici un constructeur spécifique (qui prend des arguments) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // possibilité d'appeler le constructeur de la classe mère (ici Object) + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // Les constructeurs peuvent s'enchaîner + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // Syntaxe de méthode : + // <public/private/protected> <type de retour> <nom de methode>(<args>) + + // Les classes peuvent implémenter des accesseurs pour leurs champs + // ou implémenter des propriétés (c'est la méthode dominante en C#) + + // Les paramètres de méthodes peuvent avoir des valeurs par défaut + // Dans ce cas, la méthode peut être appelée sans arguments + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // Les propriétés se chargent de lire/modifier des valeurs + // elles peuvent être en lecture(get), en écriture(set) ou les deux + private bool _hasTassles; // variable privée + public bool HasTassles // propriété publique + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // Il est possible de définir une propriété automatique sur une ligne + // cette syntaxe créera une variable de stockage automatiquement. + // Il est possible de modifier l'accèsibilité des getter/setter pour limiter leur utilisation + public bool IsBroken { get; private set; } + + // La même chose sur plusieurs lignes + public int FrameSize + { + get; + // Notez que seule la classe Bicycle peut changer la valeur de FrameSize + private set; + } + + // Méthode qui affiche la valeur des champs de cet objet + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Les méthodes peuvent aussi être statiques. Utile pour les méthodes d'aide. + public static bool DidWeCreateEnoughBycles() + { + // À l'intérieur d'une méthode statique on ne peut que référencer des membres statiques ! + return BicyclesCreated > 9000; + } // Si votre classe n'a que des membres statiques, marquez la comme statique + + } // fin de la classe Bicycle + + // PennyFarthing est une classe dérivée de Bicycle + class PennyFarthing : Bicycle + { + // Appel au constructeur de la classe mère + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + // Lève une exception + throw new ArgumentException("Impossible de modifier Gear sur un PennyFarthing"); + } + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Appel à la version de base de cette méthode + return result; + } + } + + // Les interfaces contiennent uniquement la signature de leurs membres, sans implémentation. + interface IJumpable + { + void Jump(int meters); // Tous les membres d'interface sont publics par défaut + } + + interface IBreakable + { + bool Broken { get; } // Les interfaces peuvent contenir des propriétés, + // des méthodes et des évènements + } + + // Une classe ne peut hériter que d'une seule autre classe, mais peut implémenter plusieurs interfaces + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// Utilisé pour illustrer la connexion à une base donnée dans l'exemple LinqToSql + /// L'approche code first d'EntityFramework est très pratique (un peu comme ActiveRecord de Ruby) + /// http://msdn.microsoft.com/fr-fr/data/jj193542.aspx + /// </summary> + public class BikeRespository : DbSet + { + public BikeRespository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // Fin du namespace +``` + +## Sujets non-abordés + + * Flags + * Attribus + * Propriétés statiques + * Exceptions, Abstraction + * ASP.NET (Web Forms/MVC/WebMatrix) + * Winforms + * Windows Presentation Foundation (WPF) + +## Lectures Complémentaires + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + +[Convention de codage C#](http://msdn.microsoft.com/library/vstudio/ff926074) diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown new file mode 100644 index 00000000..bdab9715 --- /dev/null +++ b/fr-fr/css-fr.html.markdown @@ -0,0 +1,221 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["@prrrnd", "https://github.com/prrrnd"] +lang: fr-fr +--- + +Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs, +des pages avec du contenu visuel sont arrivées. +CSS est le langage standard qui existe et permet de garder une séparation entre +le contenu (HTML) et le style d'une page web. + +En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents +sur une page HTML afin de leur donner des propriétés visuelles différentes. + +Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0 +qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur. + +**NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage. +Cet article porte principalement sur la syntaxe et quelques astuces. + + +```css +/* Les commentaires sont entourés par slash-étoile, comme cette ligne! */ + +/* #################### + ## SÉLECTEURS + ####################*/ + +/* Généralement, la première déclaration en CSS est très simple */ +selecteur { propriete: valeur; /* autres proprietés...*/ } + +/* Le sélécteur sert à cibler un élément du HTML + +Vous pouvez cibler tous les éléments d'une page! */ +* { color:red; } + +/* +Voici un élément dans notre HTML : + +<div class='une-classe classe2' id='unId' attr='valeur' /> +*/ + +/* Vous pouvez le cibler par une classe */ +.une-classe { } + +/* ou par deux */ +.une-classe.classe2 { } + +/* ou par son type */ +div { } + +/* ou son id */ +#unId { } + +/* ou par le fait qu'il a un attribut */ +[attr] { font-size:smaller; } + +/* ou que l'attribut a une valeur spécifique */ +[attr='valeur'] { font-size:smaller; } + +/* commence avec une valeur */ +[attr^='val'] { font-size:smaller; } + +/* termine avec une valeur */ +[attr$='eur'] { font-size:smaller; } + +/* contient une valeur */ +[attr~='leu'] { font-size:smaller; } + + +/* Ce qu'il faut bien comprendre, c'est que vous pouvez combiner ceci -- Il ne doit pas y avoir +d'espaces entre. */ +div.une-classe[attr$='eu'] { } + +/* Vous pouvez aussi cibler un élément par son parent. */ + +/* Un élément qui est en enfant direct */ +div.un-parent > .enfant {} + +/* Cela cible aussi les .enfants plus profonds dans la structure HTML */ +div.un-parent .enfants {} + +/* Attention : le même sélecteur sans espace a un autre sens. */ +div.un-parent.classe {} + +/* Vous pouvez cibler un élément basé sur un enfant de même parent */ +.je-suis-avant + .cet-element { } + +/* ou n'importe quel enfant de même parent avec celui ci */ +.je-suis-tout-avant ~ .cet-element {} + +/* Il y a des pseudo-classes qui permettent de cibler un élément +basé sur le comportement, en plus de la structure de la page */ + +/* élément avec le curseur au-dessus */ +:hover {} + +/* lien visité */ +:visited {} + +/* lien non visité */ +:link {} + +/* élément avec le focus */ +:focus {} + + +/* #################### + ## PROPRIÉTÉS + ####################*/ + +selecteur { + + /* Units */ + width: 50%; /* pourcentage */ + font-size: 2em; /* taille de la police multipliée par X */ + width: 200px; /* pixels */ + font-size: 20pt; /* points */ + width: 5cm; /* centimetres */ + width: 50mm; /* millimetres */ + width: 5in; /* pouces */ + + /* Couleurs */ + background-color: #F6E; /* court hex */ + background-color: #F262E2; /* long hex */ + background-color: tomato; /* couleur nommée */ + background-color: rgb(255, 255, 255); /* rouge, vert, bleu */ + background-color: rgb(10%, 20%, 50%); /* rouge, vert, bleu en pourcent */ + background-color: rgba(255, 0, 0, 0.3); /* rouge, vert, bleu avec transparence */ + + /* Images */ + background-image: url(/chemin-vers-image/image.jpg); + + /* Polices */ + font-family: Arial; + font-family: "Courier New"; /* Si espace, entre guillemets */ + font-family: "Courier New", Trebuchet, Arial; /* Si la première n'est pas trouvée, la deuxième est utilisée, etc... */ +} + +``` + +## Utilisation + +Le CSS s'écrit dans des fichiers `.css`. + +```xml +<!-- Vous devez inclure le CSS dans la balise <head> : --> +<link rel='stylesheet' type='text/css' href='chemin/style.css' /> + +<!-- Vous pouvez inclure du CSS dans le HTML directement, mais ce n'est vraiment pas recommandé. --> +<style> + selecteur { propriete:valeur; } +</style> + +<!-- ou directement sur l'élément HTML. +PS : à ne pas faire. --> +<div style='propriete:valeur;'> +</div> + +``` + +## Priorités + +Comme on vient de le voir, un élément peut être ciblé par plus qu'un seul sélecteur +et une même propriété peut être définie plusieurs fois. +Dans ces cas, une des propriétés devient prioritaire. + +Voici du code CSS : + +```css +/*A*/ +p.classe1[attr='valeur'] + +/*B*/ +p.classe1 {} + +/*C*/ +p.classe2 {} + +/*D*/ +p {} + +/*E*/ +p { propriete: valeur !important; } + +``` + +et le code HTML: + +```xml +<p style='/*F*/ propriete:valeur;' class='classe1 classe2' attr='valeur'> +</p> +``` + +Les priorités de style sont : +Attention, les priorités s'appliquent aux **propriétés**, pas aux blocs entiers. + +* `E` a la priorité grâce à `!important`. +* `F` vient ensuite, car le code se trouve directement dans le HTML. +* `A` vient ensuite, car il est le plus spécifique. + plus spécifique veut dire, celui qui cible le plus l'élément +* `C` vient ensuite. Il est aussi spécifique que `B`, mais est écrit après. +* Puis `B` +* Et enfin `D`. + +## Compatibilité + +La plupart des fonctionnalités de CSS2 (et de plus en plus CSS3) sont compatibles +avec tous les navigateurs. Mais il est important de vérifier la compatibilité. + +[QuirksMode CSS](http://www.quirksmode.org/css/) est une très bonne source pour cela. + +## En savoir plus (en anglais) + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown new file mode 100644 index 00000000..55453c56 --- /dev/null +++ b/fr-fr/erlang-fr.html.markdown @@ -0,0 +1,327 @@ +--- +language: erlang +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] +translators: + - ["Julien Cretel", "https://github.com/Jubobs"] +filename: learnerlang-fr.erl +lang: fr-fr +--- + +```erlang +% Un signe pour cent marque le début d'un commentaire de fin de ligne. + +%% Deux signes pour cent sont utilisés pour commenter les fonctions. + +%%% Trois signes pour cent sont utilisés pour commenter les modules. + +% Trois symboles de ponctuation sont utilisés en Erlang. +% Les virgules (`,`) servent à séparer les paramètres dans les appels de +% fonctions, les contructeurs, et les motifs. +% Les points (`.`) (suivis par des blancs) servent à séparer les fonctions et +% les expressions dans l'interpréteur. +% Les points-virgules (`;`) servent à séparer les clauses. Ces dernières +% apparaissent dans différent cas de figure : définitions de fonctions et +% expressions `case`, `if`, `try..catch`, `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Variables et filtrage par motif +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +(L'équivalent anglais de *filtrage par motif* est *pattern patching*.) + +Nb = 42. % Chaque nom de variable doit commencer par une lettre majuscule. + +% Les variables Erlang ne peuvent être affectées qu'une seule fois ; si vous +% essayez d'affecter une autre valeur à la variable `Nb`, vous obtiendrez +% une erreur. +Nb = 43. % ** exception error: no match of right hand side value 43 + +% Dans la plupart des languages, `=` indique une affectation. En Erlang, +% cependant, `=` indique un filtrage par motif. En fait, `Gauche = Droit` +% signifie ce qui suit : évalue le côté droit (`Droit`), et ensuite filtre le +% résultat à l'aide du motif du côté gauche (`Gauche`). +Nb = 7 * 6. + +% Nombre en virgule flottante. +Pi = 3.14159. + +% Les atomes représentent des valeurs constantes non-numériques. Un atome +% commence par une lettre minuscule, suivie d'une séquence composée de +% caractères alphanumériques, de tirets bas (`_`), ou d'arobases (`@`). +Bonjour = bonjour. +AutreNoeud = exemple@noeud. + +% Les atomes de valeur autre qu'alphanumérique peuvent être délimités par +% des guillemets droits simples. +AtomeAvecEspace = 'un atome contenant des espaces'. + +% Les tuples sont similaires aux enregistrements du language C. +Point = {point, 10, 45}. + +% Pour extraire des valeurs d'un tuple, on filtre par motif avec +% l'opérateur `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% On peut utiliser `_` comme caractère joker pour les variables qui ne nous +% intéressent pas. Le symbol `_` est appelé variable muette. Contrairement +% aux variables normales, de multiples apparitions de `_` dans un même motif +% ne lient pas nécessairement à la même valeur. +Personne = {personne, {nom, {prenom, joe}, {famille, armstrong}}, + {pointure, 42}}. +{_, {_, {_, Qui}, _}, _} = Personne. % Qui = joe + +% Pour créer une liste, on écrit les éléments de la liste entre crochets, en +% les séparant par des virgules. +% Les éléments d'une liste peuvent avoir n'importe quel type. +% Le premier élément d'une liste est appelé la tête de la liste. Si on retire +% la tête d'une liste, ce qui reste est appelée la queue de la liste. +Articles = [{pommes, 10}, {poires, 6}, {lait, 3}]. + +% Si `Q` est une liste, alors `[T|Q]` est aussi une liste dont la tête est `T` +% et dont la queue est `Q`. La barre verticale (`|`) sépare la tête d'une +% liste de sa queue. +% `[]` est la liste vide. +% On peut extraire des éléments d'une liste par filtrage de motif. Si `L` est +% une liste non vide, alors l'expression `[X|Y] = L`, où `X` et `Y` sont des +% variables non affectées, va extraire la tête de la liste dans `X` et la +% queue de la liste dans `Y`. +[PremierArticle|AutresArticles] = Articles. +% PremierArticle = {pommmes, 10} +% AutresArticles = [{poires, 6}, {lait, 3}] + +% Il n'y a pas de chaînes de caractères en Erlang. Les chaînes de caractères +% ne sont rien de plus que des listes d'entiers. +% Les chaînes de caractères sont délimitées par des guillemets droits doubles +% (`"`). +Nom = "Bonjour". +[66, 111, 110, 106, 111, 117, 114] = "Bonjour". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Programmation séquentielle. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Les modules constituent l'unité de base d'un programme Erlang. Toutes les +% fonctions que l'on écrit sont enregistrées dans des modules. Les modules sont +% enregistrés dans des fichiers avec une extension `.erl`. +% Les modules doivent être compilés afin d'éxecuter le programme. +% Un module compilé a une extension `.beam`. +-module(geometrie). +-export([aire/1]). % la liste des fonctions exportées par le module. + +% La fonction `aire` est composée de deux clauses. Les clauses sont séparées +% par un point-virgule, et la dernière clause est suivie d'un point et un +% espace blanc. Chaque clause a une en-tête et un corps ; l'en-tête consiste +% en un nom de fonction suivi d'un motif (entre parenthèses), et le corps +% consiste en une séquence d'expressions, qui sont évaluées si le motif de +% l'en-tête est cohérent par rapport à la valeur des paramètres d'appel. +% L'expression est filtrée séquentiellement par les différents motifs, dans +% l'ordre dans lequel ils apparaissent dans la définition de la fonction. +aire({rectangle, Largeur, Hauteur}) -> Largeur * Hauteur; +aire({cercle, R}) -> 3.14159 * R * R. + +% Compilation du code du fichier geometrie.erl. +c(geometrie). % {ok,geometrie} + +% Le nom du module doit être inclus avec le nom de la fonction afin +% d'identifier précisément quelle fonction on souhaite appeler. +geometrie:aire({rectangle, 10, 5}). % 50 +geometrie:area({cercle, 1.4}). % 6.15752 + +% En Erlang, deux fonctions portant le même nom mais ayant des arités +% différentes (c'est à dire ne prenant pas le même nombre de paramètres) +% au sein d'un même module représentent des fonctions complètement +% différentes. +-module(lib_divers). +-export([somme/1]). % exporte la fonction `somme` d'arité 1 + % acceptant un paramètre : une liste d'entiers. +somme(L) -> somme(L, 0). +somme([], N) -> N; +somme([T|Q], N) -> somme(Q, T+N). + +% Les `fun`s sont des fonctions "anonymes" ; elles sont appelées ainsi parce +% qu'elles n'ont pas de nom. Cependant, elles peuvent être affectées à des +% variables. +Doubler = fun(X) -> 2 * X end. % `Doubler` pointe vers une fonction anonyme + % dont le handle est : #Fun<erl_eval.6.17052888> +Doubler(2). % 4 + +% Les fonctions peuvent prendre des `fun`s comme paramètres et peuvent renvoyer +% des `fun`s. +Mult = fun(Fois) -> ( fun(X) -> X * Fois end ) end. +Tripler = Mult(3). +Tripler(5). % 15 + +% Les listes en compréhension sont des expressions qui créent des listes sans +% requérir ni `fun`s, ni maps, ni filters. +% La notation `[F(X) || X <- L]` signifie "la liste des `F(X)` où `X` est +% extrait de la liste `L`." +L = [1,2,3,4,5]. +[2 * X || X <- L]. % [2,4,6,8,10] +% Une liste en compréhension peut être constituée de générateurs, ainsi que de +% gardes, qui sélectionnent un sous-ensemble des valeurs générées. +NombresPairs = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% La garde est un élément syntaxique qui rend le filtrage par motif encore +% plus puissant. Les gardes permettent de d'effectuer de simple tests et +% comparaisons sur les variables d'un motif. Les gardes peuvent être +% utilisées dans les en-têtes de fonctions, au sein desquelles elles sont +% introduites par le mot-clé `when`, ou encore à n'importe quel endroit où +% une expression est autorisée. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Une garde est une série d'expressions gardes, séparées par des virgules (`,`). +% La garde `ExprGarde1, ExprGarde2, ..., ExprGardeN` est vraie si toutes les +% expressions gardes `ExprGarde1`, `ExprGarde2, ..., `ExprGardeN` ont pour +% valeur `true`. +est_chat(A) when is_atom(A), A =:= chat -> true; +est_chat(A) -> false. +est_chien(A) when is_atom(A), A =:= chien -> true; +est_chien(A) -> false. + +% Une séquence de gardes est composée soit d'une seule garde ou bien d'une +% série de gardes, séparées par des points-virgules (`;`). La séquence de +% gardes `G1; G2; ...; Gn` est vraie si au moins l'une des gardes `G1`, `G2`, +% ..., `Gn` a pour valeur `true`. +est_animal(A) when is_atom(A), (A =:= chien) or (A =:= chat) -> true; +est_animal(A) -> false. + +% Attention : toutes les expressions Erlang valides ne peuvent pas être +% utilisées comme expressions gardes ; en particulier, nos fonctions +% `est_chat` et `est_chien` ne sont pas autorisées au sein de la séquence de +% gardes dans la définition de `est_animal`. Pour plus de détails sur les +% expressions autorisées ands les séquences de gardes, voir cette +% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912) +% du manuel Erlang. + +% Les enregistrements permettent d'associer un nom à un certain élément dans +% un tuple. +% Les enregistrements peuvent être définis dans des fichiers sources Erlang +% ou bien dans des fichiers avec une extension `.hrl`, qui sont ensuite inclus +% dans des fichiers sources Erlang. +-record(afaire, { + statut = rappel, % Valeur par défaut + qui = joe, + texte +}). + +% Les définitions d'enregistrements doivent être lues dans l'interpreteur +% pour qu'on puisse définir un enregistrement. On utilise la fonction `rr` +% (abbréviation de *read records* en anglais, ou *lire enregistrements* en +% français) pour ça. +rr("enregistrements.hrl"). % [afaire] + +% Création et mise à jour d'enregistrements : +X = #afaire{}. +% #afaire{statut = rappel, qui = joe, texte = undefined} +X1 = #afaire{statut = urgent, texte = "Corriger erreurs dans livre"}. +% #afaire{statut = urgent, qui = joe, texte = "Corriger erreurs dans livre"} +X2 = X1#afaire{statut = fini}. +% #afaire{statut = fini, qui = joe, texte = "Corriger erreurs dans livre"} + +% Expressions `case`. +% `filter` renvoie une liste de tous les éléments `X` d'une liste `L` pour +% lesquels `P(X)` est vrai. +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% Expressions `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil + end. + +% Attention : au moins l'une des gardes dans l'expression `if` doit avoir pour +% valeur `true` ; autrement, une exception sera lancée. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Exceptions. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Des exceptions sont lancées par le système quand des erreurs internes +% surviennent, ou de manière explicite dans le programme en appelant +% `throw(Exception)`, `exit(Exception)`, ou `erlang:error(Exception)`. +generer_exception(1) -> a; +generer_exception(2) -> throw(a); +generer_exception(3) -> exit(a); +generer_exception(4) -> {'EXIT', a}; +generer_exception(5) -> erlang:error(a). + +% Erlang dispose de deux méthodes pour capturer une exception. La première +% consiste à inclure l'appel de de la fonction qui lance l'exception dans une +% expression `try...catch`. +catcher(N) -> + try generer_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% L'autre méthode consiste à inclure l'appel dans une expression `catch`. +% Quand une exception est capturée, elle est convertie en un tuple qui décrit +% l'erreur. +catcher(N) -> catch generer_exception(N). + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 4. Concurrence +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Erlang est basé sur le modèle d'acteur pour la concurrence. Seulement trois +% opérations sont requises pour écrire des programmes concurrents en Erlang : +% la création de processus, l'envoi de messages, et la réception de messages. + +% Pour démarrer un nouveau processus, on utilise la fonction `spawn`, qui +% prend une fonction comme paramètre. + +F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768> +spawn(F). % <0.44.0> + +% `spawn` renvoie un pid (*process identifier* en anglais, ou *identifiant de +% processus* en français), qui peut être utilisé pour envoyer des messages au +% processus en question. Pour passer des messages, on utilise l'opérateur `!`. +% Pour que cela soit utile, on doit aussi être en mesure de recevoir des +% messages, ce qui est accompli grâce à une clause `receive` : + +-module(calculerGeometrie). +-compile(export_all). +calculerAire() -> + receive + {rectangle, W, H} -> + W * H; + {cercle, R} -> + 3.14 * R * R; + _ -> + io:format("Seule l'aire d'un rectangle / cercle peut etre calculee.") + end. + +% Compilation du module and création d'un processus qui évalue `calculerAire` +% dans l'interpréteur. +c(calculerGeometrie). +CalculerAire = spawn(calculerGeometrie, calculerAire, []). +CalculerAire ! {cercle, 2}. % 12.56000000000000049738 + +% L'interpréteur est lui-même un processus ; on peut utiliser `self` pour +% obtenir le pid actuel. +self(). % <0.41.0> + +``` + +## Ressources (en anglais) + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown new file mode 100644 index 00000000..16558e7e --- /dev/null +++ b/fr-fr/go-fr.html.markdown @@ -0,0 +1,439 @@ +--- +name: Go +category: language +language: Go +lang: fr-fr +filename: learngo.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] + - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] +--- + +Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la +dernière tendance en ce qui est au développement, mais c'est la nouvelle façon +de régler des défis réels de façon rapide. + +Le langage possède des concepts familiers à la programmation impérative avec +typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à +comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des +fonctionnalités facilitant le développement à grande échelle. + +Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une +communauté active. + +```go +// Commentaire ligne simple +/* Commentaire + multiligne */ + +// Un paquet débute avec une clause "package" +// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt +// qu'une bibliothèque +package main + +// "Import" déclare les paquets référencés dans ce fichier. +import ( + "fmt" // Un paquet dans la bibliothèque standard. + "io/ioutil" // Implémente des fonctions utilitaires I/O. + m "math" // Bibliothèque mathématique utilisant un alias local "m". + "net/http" // Un serveur Web! + "strconv" // Bibliothèque pour convertir les chaînes de caractères. +) + +// Une définition de fonction. La fonction "main" est spéciale - c'est le point +// d'entrée du binaire. +func main() { + // Println retournera la valeur à la console. + // Associez la fonction avec son paquet respectif, fmt. + fmt.Println("Hello world!") + + // Appelez une fonction différente à partir de ce paquet. + beyondHello() +} + +// Les fonctions ont des paramètres entre parenthèses. +// Les parenthèses sont nécessaires avec ou sans paramètre. +func beyondHello() { + var x int // Déclaration de variable. Les variables doivent être déclarées + // avant leur utilisation. + x = 3 // Assignation de valeur. + // Les déclarations courtes utilisent := pour inférer le type, déclarer et + // assigner. + y := 4 + sum, prod := learnMultiple(x, y) // La fonction retourne deux valeurs. + fmt.Println("sum:", sum, "prod:", prod) // Affichage simple. + learnTypes() // < y minutes, en savoir plus! +} + +// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Deux valeurs retournées. +} + +// Quelques types inclus et littéraux. +func learnTypes() { + // Une déclaration courte infère généralement le type désiré. + str := "Learn Go!" // Type string. + + s2 := `Une chaîne de caractères peut contenir des +sauts de ligne.` // Chaîne de caractère. + + // Littéral non-ASCII. Les sources Go utilisent le charset UTF-8. + g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère + // unicode. + + f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit. + c := 3 + 4i // complex128, considéré comme deux float64 par le compilateur. + + // Syntaxe "var" avec une valeur d'initialisation. + var u uint = 7 // Non signé, mais la taille dépend selon l'entier. + var pi float32 = 22. / 7 + + // Conversion avec syntaxe courte. + n := byte('\n') // byte est un alias du type uint8. + + // Les tableaux ont une taille fixe déclarée à la compilation. + var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0. + a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3 + // éléments, contenant les valeurs 3, 1 et 5. + + // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun + // des avantages, mais les cas d'utilisation des slices sont plus fréquents. + s3 := []int{4, 5, 9} // Comparable à a3. + s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0. + var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire. + bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes. + + // Parce qu'elles sont dynamiques, les slices peuvent être jointes sur + // demande. Pour joindre un élément à une slice, la fonction standard append() + // est utilisée. Le premier argument est la slice à utiliser. Habituellement, + // la variable tableau est mise à jour sur place, voir ci-bas. + s := []int{1, 2, 3} // Le résultat est une slice de taille 3. + s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6. + fmt.Println(s) // La valeur est de [1 2 3 4 5 6] + + // Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs + // atomiques, il est possible de mettre en argument une référence de + // slice littérale grâce aux points de suspension. + s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice + // littérale. + fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9] + + p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int. + fmt.Println(*p, *q) // * suit un pointeur. Ceci retourne deux ints. + + // Les maps sont des tableaux associatifs de taille dynamique, comme les + // hash ou les types dictionnaires de certains langages. + m := map[string]int{"trois": 3, "quatre": 4} + m["un"] = 1 + + // Les valeurs inutilisées sont considérées comme des erreurs en Go. + // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur. + _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs + + // Cependant, son affichage en console est considéré comme une utilisation, + // ce qui ne sera pas considéré comme une erreur à la compilation. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // De retour dans le flux. +} + +// Il est possible, à l'opposé de plusieurs autres langages, de retourner des +// variables par leur nom à partir de fonctions. +// Assigner un nom à un type retourné par une fonction permet de retrouver sa +// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus. +func learnNamedReturns(x, y int) (z int) { + z = x * y + return // z est implicite, car la variable a été définie précédemment. +} + +// La récupération de la mémoire est automatique en Go. Le langage possède des +// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous +// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un +// pointeur. +func learnMemory() (p, q *int) { + // Les valeurs retournées p et q auront le type pointeur int. + p = new(int) // Fonction standard "new" alloue la mémoire. + // Le int alloué est initialisé à 0, p n'est plus nil. + s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire. + s[3] = 7 // Assigne l'un des entiers. + r := -2 // Déclare une autre variable locale. + return &s[3], &r // & retourne l'adresse d'un objet. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas + // nécessaires pour contenir le test booléen. + if true { + fmt.Println("voilà!") + } + // Le formatage du code est standardisé par la commande shell "go fmt." + if false { + // bing. + } else { + // bang. + } + // Utilisez "switch" au lieu des "if" en chaîne + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Les "case" n'ont pas besoin de "break;". + case 43: + // Non-exécuté. + } + // Comme les "if", les "for" n'utilisent pas de parenthèses. + // Les variables déclarées dans les "for" et les "if" sont locales à leur + // portée. + for x := 0; x < 3; x++ { // ++ est une incrémentation. + fmt.Println("itération ", x) + } + // x == 42 ici. + + // "For" est le seul type de boucle en Go, mais possède différentes formes. + for { // Boucle infinie + break // C'est une farce + continue // Non atteint. + } + + // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une + // chaîne, une map ou un canal. Les "range" retournent un canal ou deux + // valeurs (tableau, slice, chaîne et map). + for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} { + // pour chaque pair dans une map, affichage de la valeur et clé + fmt.Printf("clé=%s, valeur=%d\n", key, value) + } + + // À l'opposé du "for", := dans un "if" signifie la déclaration et + // l'assignation y en premier, et ensuite y > x + if y := expensiveComputation(); y > x { + x = y + } + // Les fonctions littérales sont des fermetures. + xBig := func() bool { + return x > 10000 + } + fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x). + x = 1.3e3 // Ceci fait x == 1300 + fmt.Println("xBig:", xBig()) // Maintenant false. + + // De plus, les fonctions littérales peuvent être définies et appelées + // sur la même ligne, agissant comme argument à cette fonction, tant que: + // a) la fonction littérale est appelée suite à (), + // b) le résultat correspond au type de l'argument. + fmt.Println("Ajoute + multiplie deux nombres : ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Appelle la fonction avec les arguments 10 et 2 + // => Ajoute + double deux nombres : 24 + + // Quand vous en aurez besoin, vous allez l'adorer. + goto love +love: + + learnFunctionFactory() // func retournant func correspondant à fun(3)(3). + learnDefer() // Un survol de cette instruction importante. + learnInterfaces() // Incontournable ! +} + +func learnFunctionFactory() { + // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique. + fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!")) + + d := sentenceFactory("été") + fmt.Println(d("Une matinée d'", "agréable!")) + fmt.Println(d("Une soirée d'", "relaxante!")) +} + +// Le décorateur est un patron de conception commun dans d'autres langages. +// Il est possible de faire de même en Go avec des fonctions littérales +// acceptant des arguments. +func sentenceFactory(mystring string) func(before, after string) string { + return func(before, after string) string { + return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne + } +} + +func learnDefer() (ok bool) { + // Les déclarations différées sont exécutées avant la sortie d'une fonction. + defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.") + defer fmt.Println("\nCette ligne est affichée en premier parce que") + // Les déclarations différées sont utilisées fréquemment pour fermer un + // fichier, afin que la fonction ferme le fichier en fin d'exécution. + return true +} + +// Défini Stringer comme étant une interface avec une méthode, String. +type Stringer interface { + String() string +} + +// Défini pair comme étant une structure contenant deux entiers, x et y. +type pair struct { + x, y int +} + +// Défini une méthode associée au type pair. Pair implémente maintenant Stringer +func (p pair) String() string { // p s'appelle le "destinataire" + // Sprintf est une autre fonction publique dans le paquet fmt. + // La syntaxe avec point permet de faire référence aux valeurs de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // La syntaxe avec accolade défini une "structure littérale". Celle-ci + // s'évalue comme étant une structure. La syntaxe := déclare et initialise p + // comme étant une instance. + p := pair{3, 4} + fmt.Println(p.String()) // Appelle la méthode String de p, de type pair. + var i Stringer // Déclare i instance de l'interface Stringer. + i = p // Valide, car pair implémente Stringer. + // Appelle la méthode String de i, de type Stringer. Retourne la même valeur + // que ci-haut. + fmt.Println(i.String()) + + // Les fonctions dans le paquet fmt appellent la méthode String, demandant + // aux objets d'afficher une représentation de leur structure. + fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la + // méthode String. + fmt.Println(i) // Affiche la même chose que ci-haut. + + learnVariadicParams("apprentissage", "génial", "ici!") +} + +// Les fonctions peuvent être définie de façon à accepter un ou plusieurs +// paramètres grâce aux points de suspension, offrant une flexibilité lors de +// son appel. +func learnVariadicParams(myStrings ...interface{}) { + // Itère chaque paramètre dans la range. + // Le tiret bas sert à ignorer l'index retourné du tableau. + for _, param := range myStrings { + fmt.Println("paramètre:", param) + } + + // Passe une valeur variadique comme paramètre variadique. + fmt.Println("paramètres:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec + // succès ou non + m := map[int]string{3: "trois", 4: "quatre"} + if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map. + fmt.Println("inexistant") + } else { + fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map. + } + // Une erreur ne retourne qu'un "ok", mais également plus d'information + // par rapport à un problème survenu. + if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur + // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax' + fmt.Println(err) + } + // Nous réviserons les interfaces un peu plus tard. Pour l'instant, + learnConcurrency() +} + +// c est un canal, un objet permettant de communiquer en simultané de façon +// sécurisée. +func inc(i int, c chan int) { + c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à + // gauche. +} + +// Nous utiliserons inc pour incrémenter des nombres en même temps. +func learnConcurrency() { + // La fonction "make" utilisée précédemment pour générer un slice. Elle + // alloue et initialise les slices, maps et les canaux. + c := make(chan int) + // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés + // simultanément, peut-être en paralèle si la machine le permet et configurée + // correctement. Les trois utilisent le même canal. + go inc(0, c) // go est une instruction démarrant une nouvelle goroutine. + go inc(10, c) + go inc(-805, c) + // Lis et affiche trois résultats du canal - impossible de savoir dans quel + // ordre ! + fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de + // "réception". + + cs := make(chan string) // Un autre canal, celui-ci gère des chaînes. + ccs := make(chan chan string) // Un canal de canaux de chaînes. + go func() { c <- 84 }() // Démarre une nouvelle goroutine, pour + // envoyer une valeur. + go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci. + // Select possède une syntaxe similaire au switch, mais chaque cas requiert + // une opération impliquant un canal. Il sélectionne un cas aléatoirement + // prêt à communiquer. + select { + case i := <-c: // La valeur reçue peut être assignée à une variable, + fmt.Printf("c'est un %T", i) + case <-cs: // ou la valeur reçue peut être ignorée. + fmt.Println("c'est une chaîne") + case <-ccs: // Un canal vide, indisponible à la communication. + fmt.Println("ne surviendra pas.") + } + // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines + // démarrée plus haut a complétée, la seconde restera bloquée. + + learnWebProgramming() // Go permet la programmation Web. +} + +// Une seule fonction du paquet http démarre un serveur Web. +func learnWebProgramming() { + + // Le premier paramètre de ListenAndServe est une adresse TCP à écouter. + // Le second est une interface, de type http.Handler. + go func() { + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // n'ignorez pas les erreurs ! + }() + + requestServer() +} + +// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible +// avec les opérations utilisant l'interface http.Handler. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Répondez à une requête à l'aide de la méthode http.ResponseWriter. + w.Write([]byte("Vous avez appris Go en Y minutes!")) +} + +func requestServer() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nLe serveur Web a dit: `%s`", string(body)) +} +``` + +## En savoir plus + +La référence Go se trouve sur [le site officiel de Go](http://golang.org/). +Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus. + +Une lecture de la documentation du langage est grandement conseillée. C'est +facile à lire et très court (comparé aux autres langages). + +Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go. + +Sur la liste de lecteur des étudiants de Go se trouve le [code source de la +librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre +le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous +pouvez cliquer sur le nom d'une fonction dans [la +documentation](http://golang.org/pkg/) et le code source apparaît! + +Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/). diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown new file mode 100644 index 00000000..d9d3151f --- /dev/null +++ b/fr-fr/haskell.html.markdown @@ -0,0 +1,431 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["David Baumgartner", "http://davidbaumgartner.ch"] +lang: fr-fr +filename: learnhaskell-fr.hs +--- + +Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie. + +```haskell +-- Un commentaire en une ligne commence avec deux tirets. +{- Un commentaire sur plusieurs lignes peut être contenu dans +un bloc de cette façon. +-} + +---------------------------------------------------- +-- 1. Types de données primitifs et opérateurs +---------------------------------------------------- + +-- Vous avez les nombres +3 -- 3 + +-- Les maths sont comme vous vous y attendez +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- La division n'est pas entière par défaut +35 / 4 -- 8.75 + +-- division entière +35 `div` 4 -- 8 + +-- Les booléens sont primitifs +True +False + +-- Opérations avec les booléens +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur. +-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous +-- les arguments sont juste listés après la fonction. Le schéma général est +-- donc : +-- func arg1 arg2 arg3... +-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres. + +-- Caractères et chaînes de caractère +"Ceci est une chaîne de caractère." +'a' -- caractère +'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur ! + +-- Les chaînes peuvent être concaténées +"Hello " ++ "world!" -- "Hello world!" + +-- Une chaîne de caractère est *réellement* une liste +"Ceci est une chaîne." !! 0 -- 'C' + + +---------------------------------------------------- +-- Listes et tuples +---------------------------------------------------- + +-- Tous les éléments d'une liste doit avoir le même type. +-- les deux lignes suivantes sont semblables +[1, 2, 3, 4, 5] +[1..5] + +-- Il y a aussi des listes infinies en Haskell ! +[1..] -- une liste de tous les nombres naturels + +-- Les listes infinies fonctionnent parce que Haskell est « paresseux »: +-- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez +-- donc vous demander le 1000e élément de votre liste et il vous le donnera : + +[1..] !! 999 -- 1000 + +-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste +-- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais +-- le faire à moins qu'il ne le doive. + +-- Adjoindre deux listes +[1..5] ++ [6..10] + +-- ajouter au début de la liste +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- l'indice d'une liste +[0..] !! 5 -- 5 + +-- d'autres opérations sur les listes +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +--liste en compréhension +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +--avec un conditionnel +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Chaque élément d'un tuple peut être d'un type différent, mais un +-- tuple a une longueur fixée. +-- Un tuple : +("haskell", 1) + +-- accéder aux éléments d'un tuple +fst ("haskell", 1) -- "haskell" +snd ("haskell", 1) -- 1 + +---------------------------------------------------- +-- 3. Functions +---------------------------------------------------- +-- Une simple fonction qui prend deux paramètres +add a b = a + b + +-- Notez que si vous utilisez ghci (l'interpréteur Haskell) +-- vous devrez utiliser `let`. Par exemple : +-- let add a b = a + b + +-- Utiliser une fonction +add 1 2 -- 3 + +-- Vous pouvez également mettre le nom de la fonction entre les +-- deux arguments avec des accents graves : +1 `add` 2 -- 3 + +-- Vous pouvez également définir des fonctions qui n'ont pas de +-- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà +-- un opérateur qui fait une division entière : +(//) a b = a `div` b +35 // 4 -- 8 + +-- Gardes : Une façon de gérer la valeur de vos arguments en amont +fib x + | x < 2 = x + | otherwise = fib (x - 1) + fib (x - 2) + +-- Le filtrage par motif est similaire. Là, on a donné trois +-- définitions différentes de `fib`. Haskell appellera automatiquement +-- la première fonction qui correspond au motif de la valeur. +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Filtrage par motif sur un tuple. +foo (x, y) = (x + 1, y + 2) + +-- Filtrage par motif sur des listes. Ici, `x` est le premier +-- élément de la liste, et `xs` le reste. On peut écrire notre +-- propre fonction `map` : +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- Les fonctions anonymes sont créées avec des barres obliques +-- inverses, suivies de tous les arguments. +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- Une utilisation de fold (appelée `inject` dans quelques autres +-- langages) avec comme paramètre une fonction anonyme. +-- `foldl1` veut dire fold left -- soit littéralement pli gauche -- +-- et utilise la première valeur de la liste comme accumulateur. +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Plus de fonctions +---------------------------------------------------- + +-- curryfication : si vous n'appliquez pas tous les arguments à une +-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne +-- une fonction qui prend le reste des arguments. + +add a b = a + b +foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10 +foo 5 -- 15 + +-- Une autre façon de l'écrire +foo = (+10) +foo 5 -- 15 + +-- Composition de fonctions +-- la fonction (.) enchaîne deux fonctions. +-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute +-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale. +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + +-- fixation de priorité +-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité +-- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite +-- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` +-- pour vous débarrasser de beaucoup de parenthèses : + +-- avant +(even (fib 7)) -- False + +-- ensuite +even . fib $ 7 -- False + +---------------------------------------------------- +-- 5. Signature de type +---------------------------------------------------- + +-- Haskell a un système de types très strict : par exemple, tout a un type. + +-- Quelques types simples : +5 :: Integer +"hello" :: String +True :: Bool + +-- Les fonctions ont également des types. +-- `not` prend un booléen et retourne un booléen. +-- not :: Bool -> Bool + +-- Voilà une fonction qui prend deux paramètres. +-- add :: Integer -> Integer -> Integer + +-- Quand vous définissez une valeur (souvenez-vous, tout est valeur en +-- Haskell), une bonne pratique est d'écrire son type explicitement +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. Flux de contrôle et structures conditionnelles +---------------------------------------------------- + +-- structure conditionnelle if +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- les structures if peuvent être écrites sur plusieurs lignes +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- les structures case : voilà comment vous pourriez analyser les arguments de +-- ligne de commande +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + + +-- Haskell n'a pas de boucles parce qu'il utilise la récursion. +-- `map` applique une fonction sur chaque élément d'une liste + +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- vous pouvez créer une fonction `for` en utilisant `map` +for array func = map func array + +-- et l'utiliser +for [0..5] $ \i -> show i + +-- nous aurions pu l'écrire également ainsi +for [0..5] show + +-- vous pouvez utiliser foldl et foldr pour +-- réduire une liste +-- foldl <fonction> <valeur initiale> <liste> +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- C'est donc la même chose que +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl évalue de gauche à droite, foldr +-- de droite à gauche +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Et c'est équivalent à +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. Types de données +---------------------------------------------------- + +-- Vous pouvez écrire vos propres types de données en Haskell + +data Couleur = Rouge | Bleu | Vert + +-- Et maintenant l'utiliser dans une fonction + + +say :: Couleur -> String +say Rouge = "Vous êtes Rouge !" +say Bleu = "Vous êtes Bleu !" +say Vert = "Vous êtes Vert !" + +-- Vos types peuvent également avoir des paramètres + +data Maybe a = Nothing | Just a + +-- Tous les exemples ci-dessous sont issus du type Maybe +Just "hello" -- of type `Maybe String` +Just 1 -- of type `Maybe Int` +Nothing -- of type `Maybe a` for any `a` + +---------------------------------------------------- +-- 8. Haskell IO +---------------------------------------------------- + +-- Tandis que l'IO ne peut pas être totalement expliqué pleinement +-- sans que les monades ne le soient, il n'est pas difficile +-- d'expliquer suffisamment pour commencer. + +-- Quand un programme en Haskell est exécuté, la fonction `main` +-- est appelée. Il doit retourner une valeur de type `IO ()`. +-- Par exemple : + +main :: IO () +main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) +-- putStrLn a comme type String -> IO () + +-- La façon la plus simple pour faire de l'IO est de faire un programme +-- fonction de String vers String. La fonction +-- interact :: (String -> String) -> IO () +-- prend un texte, applique une fonction et affiche le résultat. + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- Vous pouvez considérer qu'une valeur de type `IO ()` représente +-- une séquence d'actions que l'ordinateur exécute, un peu comme +-- dans un langage impératif. On peut utiliser la structure `do` +-- pour enchaîner des actions. Par exemple : + +sayHello :: IO () +sayHello = do + putStrLn "Quel est ton nom ?" + name <- getLine -- prend une ligne et assigne sa valeur à `name` + putStrLn $ "Salut, " ++ name + +-- Exercice : écrire votre propre version d'`interact` qui ne fait +-- que de lire une ligne d'entrée. + +-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule +-- action qui sera exécutée est la valeur de `main`. +-- Pour lancer `sayHello`, commentez l'ancienne définition de `main` +-- et remplacez-le par : +-- main = sayHello + +-- Essaions de mieux comprendre comment la fonction `getLine` que +-- nous venons d'utiliser. Son type est : +-- getLine :: IO String +-- vous pouvez considérer le type `IO a` comme un programme que +-- le programme va générer comme une valeur de type `a` quand +-- il sera exécuté. On peut l'enregistrer et la réutiliser en +-- utilisant `<-`. On peut aussi faire nos propres actions +-- de type `IO String` : + +action :: IO String +action = do + putStrLn "C'est une ligne. Heu" + input1 <- getLine + input2 <- getLine + -- Le type de la structure `do` est celui de sa dernière ligne. + -- `return` n'est pas un mot clef, mais simplement une fonction. + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- On peut maintenant l'utiliser comme on a utilisé `getLine` +-- tout à l'heure + +main'' = do + putStrLn "Je vais afficher deux lignes !" + result <- action + putStrLn result + putStrLn "C'était tout !" + +-- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise +-- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe +-- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO) +-- devient marqué comme `IO` dans la signature de son type. Ça nous montre +-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur +-- ou ne changent pas d'état) et quelles fonctions ne le sont pas. + +-- C'est une fonctionnalité très puissante, car il est facile d'exécuter +-- des fonctions pures simultanément, et donc la concurrence en Haskell +-- est très facile. + + +---------------------------------------------------- +-- 9. Le REPL de Haskell +---------------------------------------------------- + +-- Lancer le REPL en tapant `ghci`. +-- Vous pouvez maintenant taper du code Haskell. +-- Toutes les nouvelles valeurs peuvent être crées +-- avec `let` : + +let foo = 5 + +-- Vous pouvez voir le type de n'importe quelle valeur avec `:t` : + +>:t foo +foo :: Integer + +-- Vous pouvez également lancer des actions de type `IO ()` + +> sayHello +Quel est ton nom ? +Ami +Salut, Ami ! + +``` + +Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort : + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/). + +Vous pouvez trouver une approche beaucoup plus douce avec les excellents +[Learn you a Haskell](http://lyah.haskell.fr/) ou +[Real World Haskell (en)](http://book.realworldhaskell.org/). diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown new file mode 100644 index 00000000..15478cdb --- /dev/null +++ b/fr-fr/javascript-fr.html.markdown @@ -0,0 +1,522 @@ +--- +language: javascript +contributors: + - ['Adam Brenecki', 'http://adam.brenecki.id.au'] + - ['Ariel Krakowski', 'http://www.learneroo.com'] +filename: javascript-fr.js +translators: + - ['@nbrugneaux', 'https://nicolasbrugneaux.me'] +lang: fr-fr +--- + +JavaScript a été créé par Brendan Eich, travaillant alors a Netscape, en 1995. +Le langage avait à l'origine pour but d'être un langage de scripting simple +pour les sites web, complétant le Java (à ne pas confondre avec JavaScript) +pour des applications web complexes. Mais son intégration très proche et +simple des pages web, ainsi que le support natif des navigateurs a rendu +le JavaScript incontournable aujourd'hui tant bien dans le front-end que +dans le back-end. + +En effet, le JavaScript n'est plus uniquement limité aux navigateurs, grâce à +Node.JS, un projet qui offre un environnement indépendant dans lequel un +interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome, +peut être utilisé directement côté serveur pour exécuter des programmes écrits +en JavaScript. + +```js +// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs, +/* et les commentaires sur plusieurs lignes commencent avec slash-étoile + et finissent avec étoile-slash */ + +// Toutes les expressions peuvent finir par ; +doStuff(); + +// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés +// lors de l’interprétation aux sauts de ligne, sauf exceptions +doStuff() + +// Parce que ces cas peuvent produire des effets inattendus, nous utiliserons +// des point-virgules dans ce guide. + + +/////////////////////////////////// +// 1. Nombres, Chaines de caractères et Opérateurs + +// JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux)) +// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers) : les +// doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à +// 9 x 10¹⁵ exactement. +3; // = 3 +1.5; // = 1.5 + +// L'arithmétique de base fonctionne comme vous vous y attendriez +1 + 1; // = 2 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Ainsi que les divisions non-entières +5 / 2; // = 2.5 + +// Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération +// bits à bits, votre nombre décimal est converti en entier *jusqu'à* 32 bits. +1 << 2; // = 4 + +// Comme en mathématiques, la priorité est donnée aux parenthèses. +(1 + 3) * 2; // = 8 + +// Il existe 3 valeurs spéciales pour les nombres: +Infinity; // le résultat de 1/0 par exemple +-Infinity; // le résultat de -1/0 par exemple +NaN; // le résultat de 0/0 par exemple + +// Il existe également le type booléen. +true; // vrai +false; // faux + +// Les chaines de caractères (strings) sont créees avec " ou ' indifféremment, la seule +// raison de choisir l'un ou l'autre est la cohérence dans votre code. +"abc"; +'Hello, world'; + +// La négation utilise le symbole ! +!true; // = false +!false; // = true + +// L'égalité est === ou == +// === compare la valeur exacte 2 === '2' // = false +// == convertit la valeur pour comparer 2 === '2' // = true +// En général, il vaut mieux utiliser === pour ne pas faire d'erreur. +1 === 1; // = true +2 === 1; // = false + +// L'inégalité est !== ou !=, basé sur le même principe qu'avant. +1 !== 1; // = false +2 !== 1; // = true + +// Plus de comparaisons : +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Les chaines de caractères se concatènent avec + +'Hello ' + 'world!'; // = 'Hello world!' + +// et peuvent être comparées alphabétiquement avec < et > +'a' < 'b'; // = true + +// Vous pouvez accéder les caractères dans une string avec charAt +'This is a string'.charAt(0); // = 'T' + +// ... ou utiliser substring pour avoir un plus gros morceau +'Hello world'.substring(0, 5); // = 'Hello' + +// la longueur, length, est une propriété, donc n'utilisez pas de () +'Hello'.length; // = 5 + +// Il y a également null et undefined +null; // utilisé pour une non-valeur +undefined; // utilisé pour une valeur actuellement non présente (cependant, + // undefined est aussi une valeur valide) + +// false, null, undefined, NaN, 0 and '' sont 'presque-faux' (falsy), tout le reste +// est 'presque-vrai' (truthy) +// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0') + + +/////////////////////////////////// +// 2. Variables, Tableaux et Objets + +// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est +// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =. +var someVar = 5; + +// si vous oubliez le mot clé var, vous n'aurez pas d'erreur (sauf en mode strict) +someOtherVar = 10; + +// ... mais la variable aura une portée globale (plus communément trouvé en tant +// que "global scope" en anglais), et non pas une portée limitée à la fonction +// dans laquelle vous l'aviez définie. + +// Les variables déclarées et non assignées sont undefined par défaut +var someThirdVar; +var someThirdVar = undefined; + +// ... sont deux déclarations identiques. + +// Il y a des raccourcis pour les opérations mathématiques: +someVar += 5; // équivalent pour someVar = someVar + 5; +someVar *= 10; // de même, someVar = someVar * 100; +someVar++; // = someVar += 1; +someVar--; // = someVar -= 1; + +// Les tableaux (Arrays) sont des listes ordonnées de valeurs, de tous types. +var myArray = ['Hello', 45, true]; + +// Leurs membres peuvent être accédés en utilisant les crochets +// Les indices commencent à 0. +myArray[1]; // = 45 + +// Les tableaux sont modifiables, ainsi que leurs longueurs +myArray.push( 'World' ); +myArray.length; // = 4 + +// Ajout/Modification à un index spécifique +myArray[3] = 'Hello'; + +// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres +// langages : ils sont une liste non-ordonnée de paires clé-valeur. +var myObj = {key1: 'Hello', key2: 'World'}; + +// Les clés sont des strings, mais les ' ou " sont optionels si elles sont des +// noms valides en JavaScript. Les valeurs peuvent être de n'importe quel type. +var myObj = {myKey: 'myValue', 'my other key': 4}; + +// Les attributs d'objets peuvent être accédés avec les crochets +myObj['my other key']; // = 4 + +// .. ou avec un point si la clé est un identifiant valide. +myObj.myKey; // = 'myValue' + +// Les objets sont eux aussi modifiables. +myObj.myThirdKey = true; + +// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined +myObj.myFourthKey; // = undefined + + +/////////////////////////////////// +// 3. Logique et structures de contrôle + +// Les si (if) fonctionnent comme vous vous y attendez. +var count = 1; +if (count === 3) { + // seulement quand count est 3 +} +else if (count === 4) { + // uniquement quand count est 4 +} +else { + // le reste du temps, si ni 3, ni 4. +} + +// De même pour while. +while (true) { + // Une boucle infinie ! +} + +// Les boucles do-while sont pareilles, mais sont exécutées au moins une fois. +var input +do { + input = getInput(); +} while (!isValid(input)) + +// La boucle for est la même qu'en C ou en Java: +// initialisation; condition pour continuer; itération +for (var i = 0; i < 5; i++){ + // sera exécutée 5 fois +} + +// && est le "et" logique, || est le "ou" logique +if (house.size === 'big' && house.colour === 'blue'){ + house.contains = 'bear'; +} +if (colour === 'red' || colour === 'blue'){ + // colour est soit 'red' soit 'blue' +} + +// Les raccourcis && et || sont pratiques pour instancier des valeurs par defaut. +var name = otherName || 'default'; + +// Ceci est l'équivalent de +var name = otherName; +if (!name){ + name = 'default'; +} + +// Le switch vérifie les égalités avec === +// utilisez un "break" à la fin de chaque cas +// ou les cas suivants seront eux aussi exécutés +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. Fonctions, Scope (Environnement) et Closures + +// Les fonctions sont déclarées avec le mot clé function +function myFunction(thing){ + return thing.toUpperCase(); +} +myFunction('foo'); // = 'FOO' + +// Les fonctions JavaScript sont des objets de première classe, donc peuvent +// être réassignées à d'autres variables et passées en tant que paramètres pour +// d'autres fonctions +function myFunction(){ + // ce code s'exécutera dans 5 secondes +} +setTimeout(myFunction, 5000); +// Note: setTimeout ne fait pas parti du langage, mais les navigateurs ainsi +// que Node.js le rendent disponible + +// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être +// anonymes +setTimeout(function(){ + // ce code s'exécutera dans 5 secondes +}, 5000); + +// Le Javascript crée uniquement un scope, une portée d'action limitée, pour +// les fonctions, et pas dans les autres blocs. +if (true){ + var i = 5; +} +i; // = 5 - et non undefined comme vous pourriez vous y attendre + +// Cela a mené à un style commun de fonctions anonymes immédiatement exécutée; +// ou "immediately-executing anonymous functions" +(function(){ + var temporary = 5; + // Nous pouvons accéder au scope global en assignant à l'objet global, + // qui dans les navigateurs est "window". Il est différent dans Node.js, + // le scope global sera en fait local au module dans lequel vous + // vous trouvez. http://nodejs.org/api/globals.html + window.permanent = 10; +})(); +// Cela permet de ne pas avoir de fuites de variables qui polluent +// l’environnement global. +temporary; // raises ReferenceError +permanent; // = 10 + +// Une des fonctionnalités les plus puissantes de Javascript est le système de +// closures. Si une fonction est définie dans une autre fonction, alors la +// fonction interne aura accès aux variables de la fonction parente, même si +// celle-ci a déjà finie son exécution. +function sayHelloInFiveSeconds(name){ + var prompt = 'Hello, ' + name + '!'; + // Fonction interne + function inner(){ + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout is asynchrone, donc la fonction sayHelloInFiveSeconds quittera + // immédiatement, et setTimeout appelera inner après. +} +sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec + + +/////////////////////////////////// +// 5. Encore plus à propos des Objets; Constructeurs and Prototypes + +// Les objets peuvent contenir des fonctions. +var myObj = { + myFunc: function(){ + return 'Hello world!'; + } +}; +myObj.myFunc(); // = 'Hello world!' + +// Lorsqu'une fonction attachée à un objet est appelée, elle peut accéder à +// l'objet avec le mot clé this. +myObj = { + myString: 'Hello world!', + myFunc: function(){ + return this.myString; + } +}; +myObj.myFunc(); // = 'Hello world!' + +// La valeur de "this" change de par l'endroit où la fonction est appelée, et +// non de l'endroit où elle est définie. Donc elle ne fonctionnera pas si elle +// est appelée hors du contexte l'objet. +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// A l'inverse, une fonction peut être attachée à un objet et y gagner l'accès +// au travers de "this" +var myOtherFunc = function(){ + return this.myString.toUpperCase(); +} + +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = 'HELLO WORLD!' + +// Le contexte correspond à la valeur de "this". +// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this, +// pour une fonction quand elle est appelée grâce à "call" ou "apply". +var anotherFunc = function(s){ + return this.myString + s; +} +anotherFunc.call(myObj, ' And Hello Moon!'); // = 'Hello World! And Hello Moon!' + +// 'apply' est presque identique, mais prend un tableau comme liste d’arguments. + +anotherFunc.apply(myObj, [' And Hello Sun!']); // = 'Hello World! And Hello Sun!' + +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la +// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser +// "bind" pour garder une référence à la fonction avec ce "this". +var boundFunc = anotherFunc.bind(myObj); +boundFunc(' And Hello Saturn!'); // = 'Hello World! And Hello Saturn!' + +// "bind" peut aussi être utilisé pour créer une application partielle de la +// fonction (curry) +var product = function(a, b){ return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est +// crée et mis à disposition de la fonction via "this". Ces fonctions sont +// communément appelées constructeurs. +var MyConstructor = function(){ + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à +// une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype. + +// Quelques implémentations de JS vous laissent accéder au prototype avec la +// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard +// et ne fonctionne pas dans certains des navigateurs actuels. +var myObj = { + myString: 'Hello world!' +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 +myObj.myFunc(); // = 'hello world!' + +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + + +// Pour obtenir le prototype il existe également Object.getPrototypeOf +Object.getPrototypeOf( myObj ) // = {meaningOfLife: 42, myFunc: function} + +// Il n'y a pas de copie ici. Chacun des objets stocke une référence à son +// prototype. Cela veut dire que l'on peut le modifier et cela se répercutera +// partout. +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + +// L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change +// pas la chaine prototypale. +myObj.meaningOfLife = 42; +myPrototype.meaningOfLife; // = 43 + +// Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être +// utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype +// donné. + +// Le premier est Object.create, mais c'est assez récent et risque de ne pas +// fonctionner dans tous les navigateurs. +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// Le deuxième moyen, qui marche partout, fonctionne avec les constructeurs. +// Les constructeurs ont un propriété appelée prototype. Ce n'est *pas* le +// prototype du constructeur de la fonction elle-même, c'est le prototype que +// les nouveaux objets crées grâce à ce constructeur avec "new" auront. +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function(){ + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// Les types pré-définis tels que les strings ou nombres ont aussi des +// constructeurs +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// ... mais ils ne sont pas exactement équivalent. +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0){ + // 0 est falsy, le code ne fonctionnera pas. +} + +// Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à +// cette particularité. +String.prototype.firstCharacter = function(){ + return this.charAt(0); +} +'abc'.firstCharacter(); // = 'a' + +// C'est très souvent utilisé pour le "polyfilling", qui implémente des nouvelles +// fonctionnalités de JavaScript dans de plus anciens environnements, tels que +// les vieux navigateurs. + +//Par exemple, Object.create est assez récent, mais peut être implémenté grâce à +// ce polyfill +if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà + Object.create = function(proto){ + // on crée un constructeur temporaire avec le bon prototype + var Constructor = function(){}; + Constructor.prototype = proto; + // puis on utilise "new" pour créer un object avec ce même prototype + return new Constructor(); + } +} +``` + +## Pour aller plus loin (en anglais) + +The [Mozilla Developer +Network](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript) expose une +excellente documentation pour le Javascript dans les navigateurs. Et contient +également un wiki pour s'entraider. + +MDN's [A re-introduction to +JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +recouvre les principaux sujets vus ici. Le guide est délibérément uniquement +à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous +plutôt ici : +[Document Object +Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth +un guide pour vous éviter les faux-amis dans le JavaScript. + +[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire. + +En addition aux contributeurs de cet article, du contenu provient du +"Python tutorial" de Louie Dinh, et de [JS +Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +sur le réseau Mozilla. diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown new file mode 100644 index 00000000..49c95820 --- /dev/null +++ b/fr-fr/json-fr.html.markdown @@ -0,0 +1,62 @@ +--- +language: json +filename: learnjson-fr.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Alois de Gouvello","https://github.com/aloisdg"] +lang: fr-fr +--- + +Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes +est susceptible d'être le plus simple jamais réalisé. + +JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons +les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant, +tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. + + +```json +{ + "Clé": "valeur", + + "Clés": "devront toujours être entourées par des guillemets", + "nombres": 0, + "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".", + "a des booléens ?": true, + "rien": null, + + "grand nombre": 1.2e+100, + + "objets": { + "commentaire": "La majorité de votre strucutre sera des objets.", + + "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5], + + "un autre objet": { + "commentaire": "Ces choses peuvent être imbriquées. C'est très utile." + } + }, + + "bêtises": [ + { + "sources de potassium": ["bananes"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "style alternatif": { + "commentaire": "regarde ça !" + , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide." + , "un autre commentaire": "comme c'est gentil" + }, + + "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir." +} +``` diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown new file mode 100644 index 00000000..9c3b8003 --- /dev/null +++ b/fr-fr/livescript-fr.html.markdown @@ -0,0 +1,360 @@ +--- +language: LiveScript +filename: learnLivescript-fr.ls +contributors: + - ["Christina Whyte", "http://github.com/kurisuwhyte/"] +translators: + - ["Morgan Bohn", "https://github.com/morganbohn"] +lang: fr-fr +--- + +LiveScript est un langage qui compile en JavaScript. Il a un rapport direct +avec JavaScript, et vous permet d'écrire du JavaScript plus simplement, plus +efficacement et sans répétitivité. LiveScript ajoute non seulement des +fonctionnalités pour écrire du code fonctionnel, mais possède aussi nombre +d'améliorations pour la programmation orientée objet et la programmation +impérative. + +LiveScript est un descendant direct de [Coco][], indirect de [CoffeeScript][], +avec lequel il a beaucoup plus de compatibilité. + +[Coco]: http://satyr.github.io/coco/ +[CoffeeScript]: http://coffeescript.org/ + +Vous pouvez contacter l'auteur du guide original en anglais ici : +[@kurisuwhyte](https://twitter.com/kurisuwhyte) + + +```coffeescript +# Comme son cousin CoffeeScript, LiveScript utilise le symbole dièse pour les +# commentaires sur une ligne. + +/* + Les commentaires sur plusieurs lignes utilisent la syntaxe du C. Utilisez-les + si vous voulez préserver les commentaires dans la sortie JavaScript. + */ +``` +```coffeescript +# LiveScript utilise l'indentation pour délimiter les blocs de code plutôt que +# les accolades, et les espaces pour appliquer les fonctions (bien que les +# parenthèses soient utilisables). + + +######################################################################## +## 1. Valeurs basiques +######################################################################## + +# Les valeurs non définies sont représentées par le mot clé `void` à la place de +# `undefined` +void # comme `undefined` mais plus sûr (ne peut pas être redéfini) + +# Une valeur non valide est représentée par Null. +null + + +# Les booléens s'utilisent de la façon suivante: +true +false + +# Et il existe divers alias les représentant également: +on; off +yes; no + + +# Puis viennent les nombres entiers et décimaux. +10 +0.4 # Notez que le `0` est requis + +# Dans un souci de lisibilité, vous pouvez utiliser les tirets bas et les +# suffixes sur les nombres. Il seront ignorés à la compilation. +12_344km + + +# Les chaînes sont des séquences immutables de caractères, comme en JS: +"Christina" # Les apostrophes fonctionnent également! +"""Multi-line + strings + are + okay + too.""" + +# De temps à autre, vous voulez encoder un mot clé; la notation en backslash +# rend cela facile: +\keyword # => 'keyword' + + +# Les tableaux sont des collections ordonnées de valeurs. +fruits = + * \apple + * \orange + * \pear + +# Il peuvent être écrits de manière plus consises à l'aide des crochets: +fruits = [ \apple, \orange, \pear ] + +# Vous pouvez également utiliser la syntaxe suivante, à l'aide d'espaces, pour +# créer votre liste de valeurs: +fruits = <[ apple orange pear ]> + +# Vous pouvez récupérer une entrée à l'aide de son index: +fruits[0] # => "apple" + +# Les objets sont une collection non ordonnées de paires clé/valeur, et +# d'autres choses (que nous verrons plus tard). +person = + name: "Christina" + likes: + * "kittens" + * "and other cute stuff" + +# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des +# accolades: +person = {name: "Christina", likes: ["kittens", "and other cute stuff"]} + +# Vous pouvez récupérer une entrée via sa clé: +person.name # => "Christina" +person["name"] # => "Christina" + + +# Les expressions régulières utilisent la même syntaxe que JavaScript: +trailing-space = /\s$/ # les mots-composés deviennent motscomposés + +# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs +# lignes! +# (les commentaires et les espaces seront ignorés) +funRE = // + function\s+(.+) # nom + \s* \((.*)\) \s* # arguments + { (.*) } # corps + // + + +######################################################################## +## 2. Les opérations basiques +######################################################################## + +# Les opérateurs arithmétiques sont les mêmes que pour JavaScript: +1 + 2 # => 3 +2 - 1 # => 1 +2 * 3 # => 6 +4 / 2 # => 2 +3 % 2 # => 1 + + +# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au +# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la +# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes +# (sans conversion de type) +2 == 2 # => true +2 == "2" # => false +2 ~= "2" # => true +2 === "2" # => false + +[1,2,3] == [1,2,3] # => false +[1,2,3] === [1,2,3] # => true + ++0 == -0 # => true ++0 === -0 # => false + +# Les opérateurs suivants sont également disponibles: <, <=, > et >= + +# Les valeurs logiques peuvent être combinéees grâce aux opérateurs logiques +# `or`, `and` et `not` +true and false # => false +false or true # => true +not false # => true + + +# Les collections ont également des opérateurs additionnels +[1, 2] ++ [3, 4] # => [1, 2, 3, 4] +'a' in <[ a b c ]> # => true +'name' of { name: 'Chris' } # => true + + +######################################################################## +## 3. Fonctions +######################################################################## + +# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en +# charge des fonctions. En LiveScript, il est encore plus évident que les +# fonctions sont de premier ordre: +add = (left, right) -> left + right +add 1, 2 # => 3 + +# Les fonctions qui ne prennent pas d'arguments peuvent être appelées avec un +# point d'exclamation! +two = -> 2 +two! + +# LiveScript utilise l'environnement de la fonction, comme JavaScript. +# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de +# déclaration, et il déclarera toujours la variable située à gauche (sauf si +# la variable a été déclarée dans l'environnement parent). + +# L'opérateur `:=` est disponible pour réutiliser un nom provenant de +# l'environnement parent. + + +# Vous pouvez extraire les arguments d'une fonction pour récupérer +# rapidement les valeurs qui vous intéressent dans une structure de données +# complexe: +tail = ([head, ...rest]) -> rest +tail [1, 2, 3] # => [2, 3] + +# Vous pouvez également transformer les arguments en utilisant les opérateurs +# binaires et unaires. Définir des arguments par défaut est aussi possible. +foo = (a = 1, b = 2) -> a + b +foo! # => 3 + +# You pouvez utiliser cela pour cloner un argument en particulier pour éviter +# les effets secondaires. Par exemple: +copy = (^^target, source) -> + for k,v of source => target[k] = v + target +a = { a: 1 } +copy a, { b: 2 } # => { a: 1, b: 2 } +a # => { a: 1 } + + +# Une fonction peut être curryfiée en utilisant une longue flèche à la place +# d'une courte: +add = (left, right) --> left + right +add1 = add 1 +add1 2 # => 3 + +# Les fonctions ont un argument `it` implicite si vous n'en déclarez pas: +identity = -> it +identity 1 # => 1 + +# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez +# facilement les transformer en fonction: +divide-by-two = (/ 2) +[2, 4, 8, 16].map(divide-by-two).reduce (+) + +# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions +# composées d'autres fonctions: +double-minus-one = (- 1) . (* 2) + +# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>` +# et `<<`, qui décrivent l'ordre d'application des fonctions composées. +double-minus-one = (* 2) >> (- 1) +double-minus-one = (- 1) << (* 2) + + +# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs +# `|>` et `<|`: +map = (f, xs) --> xs.map f +[1 2 3] |> map (* 2) # => [2 4 6] + +# La version sans pipe correspond à: +((map (* 2)) [1, 2, 3]) + +# You pouvez aussi choisir où vous voulez que la valeur soit placée, en +# marquant la position avec un tiret bas (_): +reduce = (f, xs, initial) --> xs.reduce f, initial +[1 2 3] |> reduce (+), _, 0 # => 6 + + +# Le tiret bas est également utilisé pour l'application partielle, +# que vous pouvez utiliser pour toute fonction: +div = (left, right) -> left / right +div-by-two = div _, 2 +div-by-two 4 # => 2 + + +# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel. +# (mais vous devriez essayer des approches plus fonctionnelles, comme +# Promises). +# Un fonction de rappel est une fonction qui est passée en argument à une autre +# fonction: +readFile = (name, f) -> f name +a <- readFile 'foo' +b <- readFile 'bar' +console.log a + b + +# Equivalent à: +readFile 'foo', (a) -> readFile 'bar', (b) -> console.log a + b + + +######################################################################## +## 4. Conditionnalités +######################################################################## + +# Vous pouvez faire de la conditionnalité à l'aide de l'expression `if...else`: +x = if n > 0 then \positive else \negative + +# A la place de `then`, vous pouvez utiliser `=>` +x = if n > 0 => \positive + else \negative + +# Pour les conditions complexes, il vaut mieux utiliser l'expresssion `switch`: +y = {} +x = switch + | (typeof y) is \number => \number + | (typeof y) is \string => \string + | 'length' of y => \array + | otherwise => \object # `otherwise` et `_` correspondent. + +# Le corps des fonctions, les déclarations et les assignements disposent d'un +# `switch` implicite, donc vous n'avez pas besoin de le réécrire: +take = (n, [x, ...xs]) --> + | n == 0 => [] + | _ => [x] ++ take (n - 1), xs + + +######################################################################## +## 5. Compréhensions +######################################################################## + +# Comme en python, vous allez pouvoir utiliser les listes en compréhension, +# ce qui permet de générer rapidement et de manière élégante une liste de +# valeurs: +oneToTwenty = [1 to 20] +evens = [x for x in oneToTwenty when x % 2 == 0] + +# `when` et `unless` peuvent être utilisés comme des filtres. + +# Cette technique fonctionne sur les objets de la même manière. Vous allez +# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante: +copy = { [k, v] for k, v of source } + + +######################################################################## +## 4. Programmation orientée objet +######################################################################## + +# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants +# outils pour la programmation objet. La syntaxe de déclaration d'une classe +# est héritée de CoffeeScript: +class Animal + (@name, kind) -> + @kind = kind + action: (what) -> "*#{@name} (a #{@kind}) #{what}*" + +class Cat extends Animal + (@name) -> super @name, 'cat' + purr: -> @action 'purrs' + +kitten = new Cat 'Mei' +kitten.purr! # => "*Mei (a cat) purrs*" + +# En plus de l'héritage classique, vous pouvez utiliser autant de mixins +# que vous voulez pour votre classe. Les mixins sont juste des objets: +Huggable = + hug: -> @action 'is hugged' + +class SnugglyCat extends Cat implements Huggable + +kitten = new SnugglyCat 'Purr' +kitten.hug! # => "*Mei (a cat) is hugged*" +``` + +## Lectures complémentaires + +Il y a beaucoup plus de choses à dire sur LiveScript, mais ce guide devrait +suffire pour démarrer l'écriture de petites fonctionnalités. +Le [site officiel](http://livescript.net/) dispose de beaucoup d'information, +ainsi que d'un compilateur en ligne vous permettant de tester le langage! + +Jetez également un coup d'oeil à [prelude.ls](http://gkz.github.io/prelude-ls/), +et consultez le channel `#livescript` sur le réseau Freenode. diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown new file mode 100644 index 00000000..1f592320 --- /dev/null +++ b/fr-fr/lua-fr.html.markdown @@ -0,0 +1,449 @@ +--- +language: Lua +filename: learnlua-fr.lua +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] +translators: + - ["Roland Yonaba", "http://github.com/Yonaba"] +lang: fr-fr +--- + +```lua +-- Les commentaires unilignes commencent par un double tiret. + +--[[ + Les doubles crochets à la suite du double tiret + permettent d'insérer des commentaires multilignes. +--]] + +---------------------------------------------------- +-- 1. Variables et contrôle d'exécution. +---------------------------------------------------- + +num = 42 -- Tous les nombres sont de type double. +-- Rassurez vous cependant, les doubles stockés sur 64-bits +-- en réservent 52 pour la valeur exacte des entiers. La +-- précision n'est donc pas un problème pour tout entier qui +-- peut être codé sur moins de 52 bits. + +s = 'walternate' -- Chaines de caractères immuables comme en Python. +t = "une chaine avec des guillemets doubles" +u = [[les double crochets permettent + d'avoir une chaine de caractères + sur plusieurs lignes.]] +t = nil -- Affecte la valeur nulle à t; Lua possède un ramasse-miettes + +-- Le do/end définit un bloc de code +while num < 50 do + num = num + 1 -- Pas d'opérateurs de type ++ ou +=. +end + +-- Les structures en if: +if num > 40 then + print('supérieur à 40') +elseif s ~= 'walternate' then -- ~= : est différent de. + -- Le test d'égalité se fait avec == comme en Python. + io.write('inférieur à 40\n') -- Écrit par defaut sur la sortie stdout. +else + -- Les variables sont globales par défaut. + thisIsGlobal = 5 -- le style camelCase est courant. + + -- Une variable locale est déclarée avec le mot-clé local: + local line = io.read() -- Permet de lire la ligne suivante dans stdin. + + -- .. est l'opérateur de concaténation: + print("L'hiver approche, " .. line) +end + +-- Les variables non définies reçoivent par défaut la valeur nil. +foo = anUnknownVariable -- Maintenant, foo = nil. + +aBoolValue = false + +-- Seuls nil et false sont des valeurs fausses. +-- Mais 0 et '' sont des valeurs vraies! +if not aBoolValue then print('etait faux') end + +-- L'évaluation du 'or' et du 'and' est court-circuité. +-- Comme avec les ternaires du C et du JS: a?b:c +ans = aBoolValue and 'oui' or 'non' --> 'non' + +karlSum = 0 +for i = 1, 100 do -- Les bornes sont incluses dans l'intervalle. + karlSum = karlSum + i +end + +-- Utilisez "100, 1, -1" pour la décrémentation: +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- En général, l'intervalle est début, fin[, pas]. + +-- Un autre type de boucle: +repeat + print('the way of the future') + num = num - 1 +until num == 0 + + +---------------------------------------------------- +-- 2. Fonctions. +---------------------------------------------------- + +function fib(n) + if n < 2 then return n end + return fib(n - 2) + fib(n - 1) +end + +-- Lua implémente les fermetures et les fonctions anonymes: +function adder(x) + -- La fonction retournée est créée lorsque adder est appelé + -- et elle se rappelle de la valeur de x. + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- Les valeurs de retour, les appels de fonction, les assignations +-- supportent tous les listes qui peuvent ne pas correspondre en longueur. +-- Dans ce cas, les variables à assigner en supplément reçoivent nil +-- tandis que les valeurs à attribuer en supplément sont ignorées + +x, y = 1, 2 -- x = 1 et y = 2 +x, y, z = 1, 2 -- x = 1, y = 2 et z = nil +x, y, z = 1, 2, 3, 4 -- x = 1, y = 2, z = 3, et 4 est ignoré. + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> affiche "zaphod nil nil" +-- x = 4, y = 8, les valeurs 15 à 42 sont ignorées. + +-- Les fonctions sont des valeurs de première classe +-- et peuvent être locales/globales. +-- Les déclarations suivantes sont identiques: +function f(x) return x * x end +f = function (x) return x * x end + +-- Il en va de même pour les déclarations suivantes: +local function g(x) return math.sin(x) end +local g = function(x) return math.sin(x) end +-- Sauf que pour le dernier cas, même si local g = function(x) +-- est équivalent à local function g(x), il n'est pas possible +-- de faire appel à g à l'intérieur du corps de la fonction (récursion) + +-- À moins de déclarer la fonction auparavant: +local g; g = function (x) return math.sin(x) end + +-- À propos, les fonctions trigonométriques interprètent +-- leurs arguments en radians. +print(math.cos(math.pi)) -- affiche "-1" +print(math.sin(math.pi)) -- affiche "0" + +-- Lorsqu'une fonction est appelée avec un seul argument qui est une chaine, +-- les parenthèses peuvent être omises: +print 'hello' -- équivalent à print('hello'). + +-- Lorsqu'une fonction est appelée avec un seul argument qui est une table, +-- les parenthèses peuvent aussi être omises. +print {} -- équivalent à print({}). + + +---------------------------------------------------- +-- 3. Tables. +---------------------------------------------------- + +-- Tables = Seule structure de données en Lua; +-- Ce sont des listes assotiatives. +-- Elles sont similaires aux tables PHP ou aux objets JS : +-- des tables-dictionnaires que l'on peut utiliser en tant que listes. + +-- Tables en tant que dictionnaires: + +-- Les clés sont des chaines de caractères par défaut: +t = {key1 = 'valeur1', key2 = false} + +-- Elles peuvent être indexées avec la notation en point, comme en JS: +print(t.key1) -- Affiche "valeur1". +t.newKey = {} -- Ajoute une nouvelle paire clé/valeur. +t.key2 = nil -- Supprime la clé "key2" de la table. + +-- Notation littérale pour toute valeur non nulle en tant que clé: +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- affiche "tau" + +-- La correspondance des clés se fait par valeur pour +-- les nombres et les chaines, mais par référence pour les tables. +a = u['@!#'] -- a = 'qbert'. +b = u[{}] -- On pourrait s'attendre à 1729, mais l'on obtient nil: +-- b = nil car la clé utilisée n'est pas le même objet que celui +-- utilisé pour stocker la valeur originale 1729. + +-- Si une fonction prend en argument une seule table, l'on peut +-- omettre les parenthèses: +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- Affiche 'Sonmi~451'. + +for key, val in pairs(u) do -- Parcours d'une table. + print(key, val) +end + +-- _G est une table spéciale contenant toutes les variables globales, +-- et donc elle même. +print(_G['_G'] == _G) -- Affiche 'true'. + +-- Tables en tant que listes: + +-- De manière implicite, les clés sont des nombres entiers: +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v retourne la taille de la table v si elle est une liste. + print(v[i]) -- Attention, en Lua, les indices commencent à 1! +end +-- Il n'existe pas vraiment de type 'liste' en Lua, v est juste +-- une table avec des clés qui sont des nombres entiers consécutifs +-- commençant à 1. Lua le traite comme étant une liste. + +---------------------------------------------------- +-- 3.1 Métatables and métaméthodes. +---------------------------------------------------- + +-- Une table peut avoir une métatable qui confère à la table +-- un patron/prototype de conception (surcharge d'opération). Nous verrons +-- dans la suite comment les métatables imitent le prototypage du JS. + +f1 = {a = 1, b = 2} -- Représente la fraction a/b. +f2 = {a = 2, b = 3} + +-- Ceci créée une erreur: +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + local sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- appèle __add(f1, f2) de la métatable de f1 + +-- f1, f2 ne possèdent pas de clé qui pointent vers leur métatable, comme +-- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1). +-- La métatable est une table normale avec des clés prédéfinies, comme __add. + +-- Mais la ligne suivante génère une erreur puisque s n'a pas de métatable: +-- t = s + s +-- En implémentant de l'orienté objet, comme nous le verrons par la suite, +-- le problème est résolu. + +-- Une clé __index dans une métatable mt surcharge l'indexation dans sa table t +-- si la clé est absente de cette table t: +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- Affiche "gru"! merci à la métatable! + +-- Ainsi donc, un accès direct à une valeur dans une table via une clé +-- inexistante (ce qui normalement retourne "nil") conduira à exploiter +-- le champ __index de la métatable. Cela peut être récursif. + +-- Le champ __index peut aussi être une fonction (tbl, clé) +-- ce qui permet une gestion plus souple des indexations. + +-- Les clés __index, __add,... sont appelées métaméthodes. +-- En voici la liste complète: + +-- __add(a, b) pour a + b +-- __sub(a, b) pour a - b +-- __mul(a, b) pour a * b +-- __div(a, b) pour a / b +-- __mod(a, b) pour a % b +-- __pow(a, b) pour a ^ b +-- __unm(a) pour -a +-- __concat(a, b) pour a .. b +-- __len(a) pour #a +-- __eq(a, b) pour a == b +-- __lt(a, b) pour a < b +-- __le(a, b) pour a <= b +-- __index(a, b) <fn ou table> pour a.b +-- __newindex(a, b, c) pour a.b = c +-- __call(a, ...) pour a(...) + +---------------------------------------------------- +-- 3.2 Pseudo-orienté objet et héritage. +---------------------------------------------------- + +-- Lua n'implémente pas d'orienté objet par défaut. +-- Mais il reste possible d'imiter de plusieurs manières +-- le concept de "classe" grâce aux tables et aux métatables. + +-- L'explication pour l'exemple qui suit vient juste après. + +Dog = {} -- 1. + +function Dog:new() -- 2. + local newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('Je dis: ' .. self.sound..'!') +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'Je dis: woof! -- 8. + +-- 1. Dog agit comme une classe; c'est une simple table. +-- 2. L'expression tbl:fn(...) est identique à +-- tbl.fn(self, ...) +-- La notation : permet de passer par défaut un premier +-- argument appelé "self" à la fonction tbl.fn +-- Voir 7 & 8 ci-après pour comprendre comment self prend +-- sa valeur. +-- 3. newObj sera une instance de la classe Dog. +-- 4. self = la classe instanciée. Souvent, self = Dog, mais +-- cela peut changer du fait de l'héritage. +-- newObj reçoit les fonctions de self si l'__index des +-- métatables de newObj et de self pointent vers self. +-- 5. Rappel: setmetatable retourne son premier argument. +-- 6. La notation : fonctionne comme au 2, mais cette fois, self +-- est une instance au lieu d'être une classe. +-- 7. Similaire à Dog.new(Dog), donc self = Dog dans new(). +-- 8. Similaire à mrDog.makeSound(mrDog); self = mrDog. + +---------------------------------------------------- + +-- Exemple d'héritage: + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + local s = self.sound .. ' ' -- 2. + print(s .. s .. s..'!') +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof!' -- 4. + +-- 1. LoudDog reçoit les méthodes et les variables de Dog. +-- 2. self possède une clé 'sound', reçue de new(), voir 3. +-- 3. Similaire à LoudDog.new(LoudDog) et traduit en Dog.new(LoudDog), +-- puisque LoudDog ne possède pas de clé 'new', mais a une métatable +-- qui a la clé __index = Dog. +-- Résulat: la métatable de seymour est LoudDog, et +-- LoudDog.__index = LoudDog. Donc seymour.key deviendra soit égal à +-- seymour.key, LoudDog.key, Dog.key, selon le fait qu'il s'agira +-- de la première table ayant la clé 'key' en question, en remontant +-- dans la hiérarchie. +-- 4. La clé 'makeSound' est trouvée dans LoudDog; cela est similaire +-- à LoudDog.makeSound(seymour). + +-- Si besoin est, la méthode new() de la sous-classe est +-- identique à la méthode new() de sa classe mère: +function LoudDog:new() + local newObj = {} + -- Prépare self à être la superclasse de newObj: + self.__index = self + return setmetatable(newObj, self) +end + +---------------------------------------------------- +-- 4. Modules. +---------------------------------------------------- + + +--[[ Cette section est mise en commentaire afin que le reste du +-- ce script reste exécutable. +``` + +```lua +-- Supposons que le fichier mod.lua contienne ceci: +local M = {} + +local function sayMyName() + print('Hrunkner') +end + +function M.sayHello() + print('hello') + sayMyName() +end + +return M + +-- Un autre fichier peut exploiter le contenu défini dans mod.lua's: +local mod = require('mod') -- Exécute le fichier mod.lua. + +-- require est le moyen par défaut d'inclure des modules. +-- require agit comme: (si non trouvé en cache; voir ci-après) +local mod = (function () + <contenu de mod.lua> +end)() +-- Comme si le contenu de mod.lua était enveloppé dans le corps d'une fonction, +-- si bien que les variables locales contenues dans mod.lua sont +-- inaccessibles en dehors de ce module. + +-- Le code suivant fonctionne car mod = M (dans mod.lua): +mod.sayHello() -- Dis bonjour à Hrunkner. + +-- Le code suivant génère une erreur car sayMyName est local à mod.lua: +mod.sayMyName() -- erreur! + +-- Les valeurs retournées par require sont mises en cache, ce qui fait +-- qu'un module est toujours chargé une seule fois, même s'il est inclus +-- avec require à plusieurs reprises. + +-- Supposons que mod2.lua contienne le code "print('Hi!')". +local a = require('mod2') -- Affiche "Hi!" +local b = require('mod2') -- N'affiche rien; et a = b. + +-- dofile est identique à require, sauf qu'il ne fait pas de mise en cache: +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (le code de mod2.lua est encore exécuté) + +-- loadfile charge le contenu d'un fichier, sans l'exécuter. +f = loadfile('mod2') -- L'appel f() exécute le contenu de mod2.lua. + +-- loadstring est similaire à loadfile, mais pour les chaines de caractères. +g = loadstring('print(343)') -- Retourne une fonction. +g() -- Affiche 343; Rien n'est affiché avant cet appel. + +--]] + +``` +## Références + +*Les références qui suivent sont en Anglais.* + +Les sujets non abordés dans ce tutoriel sont couverts en intégralité par +les librairies standard: + +* La librairie <a href="http://lua-users.org/wiki/StringLibraryTutorial">string</a> +* La librairie <a href="http://lua-users.org/wiki/TableLibraryTutorial">table</a> +* La librairie <a href="http://lua-users.org/wiki/MathLibraryTutorial">math</a> +* La librairie <a href="http://lua-users.org/wiki/IoLibraryTutorial">io</a> +* La librairie <a href="http://lua-users.org/wiki/OsLibraryTutorial">os</a> + +Autres références complémentaires: + +* <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">Lua pour programmeurs</a> +* <a href="lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Référence condensée de Lua</a> +* <a href="http://www.lua.org/pil/contents.html">Programmer en Lua</a> +* <a href="http://www.lua.org/manual/">Les manuels de référence Lua</a> + +A propos, ce fichier est exécutable. Sauvegardez-le sous le nom *learn.lua* et +exécutez-le avec la commande `lua learn.lua` ! + +Ce tutoriel a été originalement écrit pour <a href="tylerneylon.com">tylerneylon.com</a> et est aussi +disponible en tant que <a href="https://gist.github.com/tylerneylon/5853042">gist</a>. +Il a été traduit en français par Roland Yonaba (voir son <a href="http://github.com/Yonaba">github</a>). + +Amusez-vous bien avec Lua! diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown new file mode 100644 index 00000000..e5e7c73a --- /dev/null +++ b/fr-fr/markdown.html.markdown @@ -0,0 +1,289 @@ +--- +language: markdown +contributors: +- ["Andrei Curelaru", "http://www.infinidad.fr"] +filename: markdown.md +lang: fr-fr +--- + +Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe +facile à lire et à écrire, aisément convertible en HTML + (et beaucoup d'autres formats aussi à présent). + +Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" +et envoyer des pull request! + + +```markdown +<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML +est un document Markdown valide. Autrement dit, vous pouvez utiliser des +balises HTML dans un fichier Markdown, comme la balise commentaire dans +laquelle nous sommes à présent, car celle-ci ne sera pas affectée par +le parser( analyseur syntaxique ) Markdown. --> + +<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown, + vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. --> + +<!-- Le Markdown est implémenté de différentes manières, selon le parser. +Ce guide va alors tenter de trier les fonctionnalités universelles de celles +spécifiques à un parser. --> + +<!-- Headers ( En-têtes ) --> +<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant + le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, + selon le niveau de titre souhaité. --> +# Ceci est un <h1> +## Ceci est un <h2> +### Ceci est un <h3> +#### Ceci est un <h4> +##### Ceci est un <h5> +###### Ceci est un <h6> + +<!-- +Markdown fournit également une façon alternative de marquer les h1 et h2 +--> + +Ceci est un h1 +============= + +Ceci est un h2 +------------- + +<!-- Styles basiques pour du texte --> +<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown --> + +*Ce texte est en italique.* +_Celui-ci aussi._ + +**Ce texte est en gras.** +__Celui-là aussi.__ + +***Ce texte a les deux styles.*** +**_Pareil ici_** +*__Et là!__* + +<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown +sur Github, on a également le strikethrough ( texte barré ) : --> + +~~Ce texte est barré avec strikethrough.~~ + +<!-- Les Paragraphes sont représentés par une ou plusieurs lignes de texte +séparées par une ou plusieurs lignes vides. --> + +Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non? + +Maintenant je suis dans le paragraphe 2. +Je suis toujours dans le paragraphe 2! + + +Puis là, eh oui, le paragraphe 3! + +<!-- +Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter +un ou plusieurs espaces à la fin de votre paragraphe, et en commencer +un nouveau. +--> + +J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). + +Bigre, il y a un <br /> au dessus de moi! + +<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > --> + +> Ceci est une superbe citation. Vous pouvez même +> revenir à la ligne quand ça vous chante, et placer un `>` +> devant chaque bout de ligne faisant partie +> de la citation. +> La taille ne compte pas^^ tant que chaque ligne commence par un `>`. + +> Vous pouvez aussi utiliser plus d'un niveau +>> d'imbrication! +> Classe et facile, pas vrai? + +<!-- les Listes --> +<!-- les Listes non ordonnées sont marquées par des asterisques, +signes plus ou signes moins. --> + +* Item +* Item +* Un autre item + +ou + ++ Item ++ Item ++ Encore un item + +ou + +- Item +- Item +- Un dernier item + +<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point --> + +1. Item un +2. Item deux +3. Item trois + +<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera +les bons chiffres. Ceci dit, cette variante perd en clarté.--> + +1. Item un +1. Item deux +1. Item trois +<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) --> + +<!-- Vous pouvez également utiliser des sous-listes --> + +1. Item un +2. Item deux +3. Item trois +* Sub-item +* Sub-item +4. Item quatre + +<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML +de type checkbox. --> + +Les [ ] ci dessous, n'ayant pas de [ x ], +deviendront des cases à cocher HTML non-cochées. + +- [ ] Première tache à réaliser. +- [ ] Une autre chose à faire. +La case suivante sera une case à cocher HTML cochée. +- [x] Ça ... c'est fait! + +<!-- les Blocs de Code --> +<!-- Pour marquer du texte comme étant du code, il suffit de commencer +chaque ligne en tapant 4 espaces (ou un Tab) --> + + echo "Ça, c'est du Code!"; + var Ça = "aussi !"; + +<!-- L'indentation par tab ou série de quatre espaces +fonctionne aussi à l'intérieur du bloc de code --> + + my_array.each do |item| + puts item + end + +<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` --> + +La fonction `run()` ne vous oblige pas à aller courir! + +<!-- Via Github Flavored Markdown, vous pouvez utiliser +des syntaxes spécifiques --> + +\`\`\`ruby +<!-- mais enlevez les backslashes quand vous faites ça, +gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )--> +def foobar +puts "Hello world!" +end +\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin --> + +<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github +va utiliser une coloration syntaxique pour le langage indiqué après les ``` --> + +<!-- Ligne Horizontale (<hr />) --> +<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, +avec ou sans espaces entre chaque un. --> + +*** +--- +- - - +**************** + +<!-- Liens --> +<!-- Une des fonctionnalités sympathiques du Markdown est la facilité +d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), +et voilà l'travail. +--> + +[Clic moi!](http://test.com/) + +<!-- +Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. +--> + +[Clic moi!](http://test.com/ "Lien vers Test.com") + +<!-- les Liens Relatifs marchent aussi --> + +[En avant la musique](/music/). + +<!-- Les liens façon "références" sont eux aussi disponibles en Markdown --> + +[Cliquez ici][link1] pour plus d'information! +[Regardez aussi par ici][foobar] si vous voulez. + +[link1]: http://test.com/ "Cool!" +[foobar]: http://foobar.biz/ "Alright!" + +<!-- Le titre peut aussi être entouré de guillemets simples, +entre parenthèses ou absent. Les références peuvent être placées +un peu où vous voulez dans le document, et les identifiants +(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques --> + +<!-- Il y a également le "nommage implicite" qui transforme le texte du lien + en identifiant --> + +[Ceci][] est un lien. + +[ceci]: http://ceciestunlien.com/ + +<!-- mais ce n'est pas beaucoup utilisé. --> + +<!-- Images --> +<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée + d'un point d'exclamation! --> + + + +<!-- Là aussi, on peut utiliser le mode "références" --> + +![Ceci est l'attribut ALT de l'image][monimage] + +[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici." + +<!-- Divers --> +<!-- Liens Automatiques --> + +<http://testwebsite.com/> est équivalent à : +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Liens Automatiques pour emails --> + +<foo@bar.com> + +<!-- Escaping --> +Il suffit de précéder les caractères spécifiques à ignorer par des backslash \ + +Pour taper *ce texte* entouré d'astérisques mais pas en italique : +Tapez \*ce texte\*. + +<!-- Tableaux --> +<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown + et c'est ce n'est pas super agréable d'utilisation. + Mais si vous en avez besoin : + --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| Alignement Gauche | Centé | Alignement Droite | +| bla | bla | bla | + +<!-- ou bien, pour un résultat équivalent : --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ough que c'est moche | svp | arrêtez + +<!-- Fin! --> + +``` + +Pour plus d'information : + consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, + et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard. diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown new file mode 100644 index 00000000..69f4d8f9 --- /dev/null +++ b/fr-fr/objective-c-fr.html.markdown @@ -0,0 +1,528 @@ +--- + +language: Objective-C +contributors: + - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] + - ["Yannick Loriot", "https://github.com/YannickL"] + - ["Levi Bostian", "https://github.com/levibostian"] +translators: + - ["Yannick Loriot", "https://github.com/YannickL"] +filename: LearnObjectiveC-fr.m +lang: fr-fr + +--- + +L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch. + +```objective_c +// Les commentaires sur une seule ligne commencent par // + +/* +Les +commentaires +multi-lignes +ressemblent +à +ceci +*/ + +// #import permet d'importer les en-têtes d'autres fichiers +// Utilisez <> pour importer des fichiers globaux (en général des frameworks) +// Utilisez "" pour importer des fichiers locaux (du projet) +#import <Foundation/Foundation.h> +#import "MaClasse.h" + +// Si vous activez les modules dans les projets iOS >= 7 ou Mac OS X >= 10.9 +// dans Xcode 5, vous pouvez importer les frameworks comme cela : +@import Foundation; + +// Le point d'entrée de votre programme est une fonction qui s'appelle main +// et qui retourne un entier comme type +int main (int argc, const char * argv[]) +{ + // Créer un groupe de libération automatique de la mémoire pour l'ensemble + // du programme + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + // Si vous utilisez le comptage de référence automatique (ARC), utilisez + // @autoreleasepool à la place : + @autoreleasepool { + + // NSLog() permet d'afficher une chaine de caractères dans la console + // Affiche la chaine de caractères "Bonjour Tous Le Monde !" + NSLog(@"Bonjour tous le Monde !"); + + /////////////////////////////////////// + // Les Types & Les Variables + /////////////////////////////////////// + + // La déclaration de primitive + int maPrimitive1 = 1; + long maPrimitive2 = 234554664565; + + // La déclaration d'objet + // Il faut mettre un astérisque devant la déclaration d'objet fortement typé + MaClasse *monObject1 = nil; // Typage fort + id monObject2 = nil; // Typage faible + // 'description' est une méthode qui permet de retourner un aperçut de l'objet sous forme textuelle + // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@' + NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" + + // Les chaines de caractères + NSString *chaineMonde = @"Monde"; + NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" + // NSMutableString est une chaine mutable + NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"]; + [chaineMutable appendString:@" Monde !"]; + NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !" + + // Les caractères + NSNumber *laLettreZSousFormeDeNombre = @'Z'; + char laLettreZ = [laLettreZSousFormeDeNombre charValue]; // ou 'Z' + NSLog(@"%c", laLettreZ); + + // Les nombres + NSNumber *nombreQuaranteDeux = @42; + int quaranteDeux = [nombreQuaranteDeux intValue]; // ou 42 + NSLog(@"%i", quaranteDeux); + + NSNumber *nombreQuaranteDeuxnonSigne = @42U; + unsigned int quaranteDeuxnonSigne = [nombreQuaranteDeuxnonSigne unsignedIntValue]; + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42]; + short quaranteDeuxCourt = [nombreQuaranteDeuxCourt shortValue]; // ou 42 + NSLog(@"%hi", fortyTwoShort); + + NSNumber *nombreQuaranteDeuxLong = @42L; + long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 + NSLog(@"%li", fortyTwoLong); + + // Les nombres flottants + NSNumber *nombrePiFlottant = @3.141592654F; + float piFlottant = [nombrePiFlottant floatValue]; // ou 3.141592654f + NSLog(@"%f", piFlottant); // affiche => 3.141592654 + NSLog(@"%5.2f", piFlottant); // affiche => " 3.14" + + NSNumber *nombrePiDouble = @3.1415926535; + double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 + NSLog(@"%f", piDouble); + NSLog(@"%4.2f", piDouble); // affiche => "3.14" + + // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres + // flottants et les doubles + NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; + NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; + // NSDecimalNumber ne permet pas d'utiliser les opérations standards (+, -, *, /) + // Il faut utiliser les méthodes suivantes à la place : + [decNumUn decimalNumberByAdding:decNumDeux]; + [decNumUn decimalNumberBySubtracting:decNumDeux]; + [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; + [decNumUn decimalNumberByDividingBy:decNumDeux]; + NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber est immuable + + // Les booléens + NSNumber *ouiNumber = @YES; + NSNumber *nonNumber = @NO; + // ou + BOOL ouiBool = YES; + BOOL nonBool = NO; + NSLog(@"%i", ouiBool); // affiche => 1 + + // Les listes + // Une liste peut contenir uniquement des objets + NSArray *uneListe = @[@1, @2, @3, @4]; + NSNumber *troisiemeNombre = uneListe[2]; + NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" + // NSMutableArray est une version mutable de NSArray + // Cela permet de modifier la liste en ajoutant de nouveaux éléments et en supprimant ou + // changeant de place des objets déjà présent + // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray + NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; + [listeMutable addObject:@"Bonjour tous le"]; + [listeMutable addObject:@"Monde"]; + [listeMutable removeObjectAtIndex:0]; + NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" + + // Les dictionnaires + // Un dictionnaire est un ensemble de clés : valeurs + NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; + NSObject *valeur = unDictionnaire[@"Une clé"]; + NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" + // NSMutableDictionary est un dictionnaire mutable, c-à-d que l'on peut modifier + NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2]; + [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"]; + [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"]; + [dictionnaireMutable removeObjectForKey:@"cle1"]; + + // Les ensembles + // Un ensemble ne peut contenir de duplicatas contrairement aux NSArray + NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; + NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre) + // NSMutableSet est un ensemble mutable + NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2]; + [ensembleMutable addObject:@"Salut"]; + [ensembleMutable addObject:@"Salut"]; + NSLog(@"%@", ensembleMutable); // affiche => {(Salut)} + + /////////////////////////////////////// + // Les Operateurs + /////////////////////////////////////// + + // Les opérateurs sont pareil qu'en C + // Par exemple : + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (NO) + 3 != 2; // => 1 (YES) + 1 && 1; // => 1 (et logique) + 0 || 1; // => 1 (ou logique) + ~0x0F; // => 0xF0 (négation bit à bit) + 0x0F & 0xF0; // => 0x00 (et bit à bit) + 0x01 << 1; // => 0x02 (décalage à gauche (par 1)) + + /////////////////////////////////////// + // Les Structures de Contrôle + /////////////////////////////////////// + + // Structure "Si-Sinon" (If-Else) + if (NO) + { + NSLog(@"Je ne suis jamais affiché"); + } else if (0) + { + NSLog(@"Je ne suis jamais affiché aussi"); + } else + { + NSLog(@"Je suis affiché"); + } + + // Structure "Selon" (Switch) + switch (2) + { + case 0: + { + NSLog(@"Je ne suis jamais affiché"); + } break; + case 1: + { + NSLog(@"Je ne suis jamais affiché aussi"); + } break; + default: + { + NSLog(@"Je suis affiché"); + } break; + } + + // Structure de boucle "Tant Que" (While) + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeur + } // => affiche "0," + // "1," + // "2," + // "3," + + // Structure de boucle "Pour" (For) + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Structure de boucle "Pour Chaque" (Foreach) + NSArray *valeurs = @[@0, @1, @2, @3]; + for (NSNumber *valeur in valeurs) + { + NSLog(@"%@,", valeur); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Structure "Essayer-Attraper-Finalement" (Try-Catch-Finally) + @try + { + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"Fichier non trouvé" userInfo:nil]; + } @catch (NSException * e) + { + NSLog(@"Une exception est survenue : %@", e); + } @finally + { + NSLog(@"Finalement"); + } // => affiche "Une exception est survenue : Fichier non trouvé" + // "Finalement" + + /////////////////////////////////////// + // Les Objets + /////////////////////////////////////// + + // Définis et créé une instance d'objet en allouant un espace mémoire puis en + // l'initialisant. Un objet n'est pas complétement fonctionnel tant que les deux + // étapes précédentes ne sont pas terminées + MaClass *monObjet = [[MaClass alloc] init]; + + // L'Objet en Objective-C est basé sur le principe d'envoie de message et non sur + // celui d'appel de méthode comme la plupart des autres langages + // C'est un détail important car cela veut dire que l'on peut envoyer un message + // à un objet qui ne possède pas la méthode demandée sans aucune incidence sur le + // fonctionnement du programme (aucune exception ne sera levée) + [myObject instanceMethodWithParameter:@"Steve Jobs"]; + + // Nettoie la mémoire qui a été utilisée dans le programme + [pool drain]; + + // Fin de l'@autoreleasepool + } + + // Fin du programme + return 0; +} + +/////////////////////////////////////// +// Les Classes et Les Fonctions +/////////////////////////////////////// + +// Déclaration d'une classe dans un en-tête de fichier (MaClasse.h) : +// La déclaration d'une classe en Objective-C commence par la déclaration de son interface : +// @interface NomDeLaClasse : NomDeLaClasseParent <ListeDesProtocoles> +// { +// type nom; // Déclaration d'une variable; +// } +// @property type nom; // Déclaration d'une propriété +// -/+ (type)nomDeLaMethode; // Déclaration d'une methode +// @end // Termine la déclaration +// NSObject est la classe de base (super classe) en Objective-C +@interface MaClasse : NSObject <MonProtocole> +{ + int nombre; // Accès protégé par défaut (équivalent à '@protected int nombre;') + @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) + NSString *nom; +} +// Les propriétés permettent de générer les accésseurs/affecteurs publiques à la compilation +// Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property +@property int propInt; // Nom de l'affecteur = 'setPropInt' +@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation +// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface +// Il faut utiliser le mot clé '@synthesize' dans l'@implementation pour créer l'accésseur +@property (readonly) NSString *roString; +// Vous pouvez aussi personnaliser les noms des accésseurs ou des affecteurs +@property (getter=longeurGet, setter=longeurSet:) int longeur; + +// Methodes ++/- (TypeDeRetour)signatureDeLaMethode:(TypeDuParametre *)nomDuParametre; + +// '+' signifie que c'est une méthode de classe (statique) : ++ (NSString *)methodeDeClasse; ++ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; + +// '-' pour les méthodes d'instances : +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; + +// Contructeur avec des arguments : +- (id)initAvecDistance:(int)distanceParDefault; +// Les méthodes en Objective-C sont très descriptives + +@end // Fin de l'interface + + +// Voici un exemple d'utilisation de MaClasse +MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse +[maClasse setNombre:10]; +NSLog(@"%d", [maClasse nombre]); // affiche => 10 +[myClass longeurSet:32]; +NSLog(@"%i", [maClasse longeurGet]); // affiche => 32 +// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux +// variables d'instances : +maClasse.nombre = 45; +NSLog(@"%i", maClasse.nombre); // maClasse => 45 + +// Pour appeler une méthode de classe : +NSString *s1 = [MaClasse methodeDeClasse]; +MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; + +// Pour appeler une méthode d'instance : +MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse +NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; + +// Les sélecteurs sont un moyen de décrire les méthodes dynamiquement +// Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions +// facilement manipulable +// SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode +SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); +if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe possède la méthode + // Met les arguments de la méthode dans un seul objet pour l'envoyer via la fonction + // performSelector:withObject: + NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; + [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode via le sélecteur +} +else { + // NSStringFromSelector() retourne une chaine de caractères à partir d'un sélecteur + NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); +} + +// Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci : +@implementation MaClasse { + long distance; // Variable d'instance privée (équivalent à @private dans l'interface) + NSNumber hauteur; +} + +// Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom +// de la variable : +_nombre = 5; +// Accès d'une variable définie dans le fichier d'implémentation : +distance = 18; +// Pour utiliser la variable définie par l'intermédiaire de @property, il faut utiliser @synthesize +// qui permet de créer les affecteurs et les accésseurs correspondants : +@synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation + +// A l'inverse dela méthode 'init' qui est appelée lors de la création d'un objet, la fonction +// 'dealloc' est appelée quand l'objet est supprimé +- (void)dealloc +{ + [hauteur release]; // Si vous n'utilisez pas ARC, pensez bien à supprimer l'objet + [super dealloc]; // et à appeler la méthode 'dealloc' de la classe parent +} + +// Les constructeurs sont des fonctions qui permettent d'instancier un objet +// 'init' est le constructeur par défaut en Objective-C +- (id)init +{ + if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent + { + self.count = 1; // 'self' permet d'appeler la méthode de l'instance courante + } + return self; +} + +// Vous pouvez aussi créer des constructeurs avec des arguments +// Attention : chaque nom de constructeur doit absolument commencer par 'init' +- (id)initAvecUneDistance:(int)distanceParDefault +{ + if ((self = [super init])) + { + distance = distanceParDefault; + return self; + } +} + +// Implémentation d'une méthode de classe ++ (NSString *)methodDeClasse +{ + return [[self alloc] init]; +} + ++ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut +{ + hauteur = hauteurParDefaut; + return [[self alloc] init]; +} + +// Implémentation d'une méthode d'instance +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string +{ + return @"Ma chaine de caractère"; +} + +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number +{ + return @42; +} + +// Pour créer une méthode privée, il faut la définir dans l'implementation et non pas dans +// l'interface +- (NSNumber *)methodePrivee +{ + return @72; +} + +[self methodePrivee]; // Appel de la méthode privée + +// Implémentation d'une méthode qui est déclarée dans <MonProtocole> +- (void)methodeDuProtocole +{ + // expressions +} + +@end // Fin de l'implémentation + +/* + * Un protocole déclare des méthodes et propriétés que chaque implémentation doit avoir afin de se + * conformer à celui-ci + * Un protocole n'est pas une classe, c'est juste une interface + */ +@protocol MonProtocole + - (void)methodeDuProtocole; +@end + + +/////////////////////////////////////// +// Gestion de la mémoire +/////////////////////////////////////// +/* +À chaque fois qu'un objet est créé dans l'application, un bloc mémoire doit être alloué. +Quand l'application en a fini avec cet objet, la mémoire doit être libérée afin d'éviter les fuites +mémoires +Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par exemple. La gestion de la +mémoire repose sur le comptage de référence qui, pour chaque objet, assigne un compteur qui permet +de connaitre le nombre de référence qui l'utilise. + +Le principe est le suivant : +Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le +compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Au moment +où le compteur arrive à zéro, l'objet est supprimé de la mémoire + +Une bonne pratique à suivre quand on travaille avec des objets est la suivante : +(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire +*/ + +MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence +[classeVar release]; // Décrémente le compteur de rérence +// 'retain' incrémente le compteur de référence +// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nul +MaClasse *nouvelleVar = [classVar retain]; +[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du bloc + +// Les @property peuvent utiliser 'retain' et 'assign' +@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle +@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur + +// Automatic Reference Counting (ARC) +// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de +// référence automatique (Automatic Reference Counting en anglais) +// ARC est une fonctionnalité du compilateur qui permet d'ajouter les 'retain', 'release' et 'autorelease' +// automatiquement. Cela veut dire que lorsque vous utilisez ARC vous ne devez plus utiliser ces mot-clés +MaClasse *arcMaClasse = [[MaClasse alloc] init]; +// ... code utilisant arcMaClasse +// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC +// activé il n'est plus nécessaire de le faire car le compilateur ajoutera l'expréssion automatiquement +// pour vous + +// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' +@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si le compteur de référence +// descend à zero, weakVar sera automatiquement mis à nil +@property (strong) MaClasse *strongVar; // 'strong' prend possession de l'objet comme le ferait avec +// le mot-clé 'retain' + +// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions +// suivantes : +__strong NSString *strongString; // Par défaut. La variable est retenue en mémoire jusqu'à la fin +// de sa portée +__weak NSSet *weakSet; // Maintient une référence vers l'objet sans incrémenter son compteur de référence : +// Lorsque l'objet sera supprimé, weakSet sera mis à nil automatiquement +__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'est pas mis à nil quand +// l'objet est supprimé + +``` +## Lectures Complémentaires + +[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) + +[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12) + +[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown new file mode 100644 index 00000000..f4eaf396 --- /dev/null +++ b/fr-fr/php.html.markdown @@ -0,0 +1,696 @@ +--- +language: PHP +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +translators: + - ["Pascal Boutin", "http://pboutin.net/"] +lang: fr-fr +--- + +This document describes PHP 5+. + +```php + // Le code PHP doit être placé à l'intérieur de balises '<?php' + +// Si votre fichier php ne contient que du code PHP, il est +// généralement recommandé de ne pas fermer la balise '?>' + +// Deux barres obliques amorcent un commentaire simple. + +# Le dièse aussi, bien que les barres obliques soient plus courantes + +/* + Les barres obliques et les astérisques peuvent être utilisés + pour faire un commentaire multi-lignes. +*/ + +// Utilisez "echo" ou "print" afficher une sortie +print('Hello '); // Affiche "Hello " sans retour à la ligne + +// Les parenthèses sont facultatives pour print et echo +echo "World\n"; // Affiche "World" avec un retour à la ligne + +// toutes les instructions doivent se terminer par un point-virgule + +// Tout ce qui se trouve en dehors des <?php ?> est automatiquement +// affiché en sortie +Hello World Again! +<?php + + +/************************************ + * Types & Variables + */ + +// Les noms de variables 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. + +// Les valeurs booléenes ne sont pas sensibles à la casse +$boolean = true; // ou TRUE ou True +$boolean = false; // ou FALSE ou False + +// Entiers (integers) +$int1 = 12; // => 12 +$int2 = -12; // => -12 +$int3 = 012; // => 10 (un 0 devant la valeur désigne une valeur octale) +$int4 = 0x0F; // => 15 (un 0x devant la valeur désigne une valeur hexadécimale) + +// Réels (floats, doubles) +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Suppression d'une variable +unset($int1); + +// Arithmétique +$sum = 1 + 1; // 2 (addition) +$difference = 2 - 1; // 1 (soustraction) +$product = 2 * 2; // 4 (produit) +$quotient = 2 / 1; // 2 (division) + +// Arithmétique (raccourcis) +$number = 0; +$number += 2; // Incrémente $number de 2 +echo $number++; // Affiche 2 (incrémente après l'évaluation) +echo ++$number; // Affiche 4 (incrémente avant l'évaluation) +$number /= $float; // Divise et assigne le quotient à $number + +// Les chaînes de caractères (strings) doivent être à +// l'intérieur d'une paire d'apostrophes +$sgl_quotes = '$String'; // => '$String' + +// Évitez les guillemets sauf pour inclure le contenu d'une autre variable +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' + +// Les caractères spéciaux sont seulement échappés avec des guillemets +$escaped = "This contains a \t tab character."; +$unescaped = 'This just contains a slash and a t: \t'; + +// En cas de besoin, placez la variable dans des accolades +$money = "I have $${number} in the bank."; + +// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes +// multi-lignes non-interprétées +$nowdoc = <<<'END' +Multi line +string +END; + +// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées +$heredoc = <<<END +Multi line +$sgl_quotes +END; + +// La concaténation de chaînes se fait avec un . +echo 'This string ' . 'is concatenated'; + + +/******************************** + * Constantes + */ + +// Une constante est déclarée avec define() +// et ne peut jamais être changée durant l'exécution + +// un nom valide de constante commence par une lettre ou un souligné, +// suivi de n'importe quelle lettre, nombre ou soulignés. +define("FOO", "something"); + +// on peut accéder à une constante en utilisant directement son nom +echo 'This outputs '.FOO; + + +/******************************** + * Tableaux (array) + */ + +// Tous les tableaux en PHP sont associatifs (hashmaps), + +// Fonctionne dans toutes les versions de PHP +$associative = array('One' => 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: +?> +<p><?= $paragraph ?></p> +<?php + +$x = 1; +$y = 2; +$x = $y; // $x contient maintenant la même valeur que $y +$z = &$y; +// $z contient une référence vers $y. Changer la valeur de +// $z changerait également la valeur de $y, et vice-versa. +// $x resterait inchangé comme la valeur initiale de $y + +echo $x; // => 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: +?> + +<?php if ($x): ?> +<p>Ceci est affiché si $x est vrai</p> +<?php else: ?> +<p>Ceci est affiché si $x est faux</p> +<?php endif; ?> + +<?php + +// On peut également utiliser une condition multiple (switch case) +switch ($x) { + case '0': + print 'Les switch font du transtypage implicite'; + break; // Il est important de déclaré un 'break', sinon les cas + // 'two' et 'three' seront évalués + case 'two': + case 'three': + // Si $x == 'two' || $x == 'three' + break; + default: + // Si aucun cas n'a été vrai +} + +// Structures itératives (for, while, do while) +$i = 0; +while ($i < 5) { + echo $i++; +}; // Affiche "01234" + +echo "\n"; + +$i = 0; +do { + echo $i++; +} while ($i < 5); // Affiche "01234" + +echo "\n"; + +for ($x = 0; $x < 10; $x++) { + echo $x; +} // Affiche "0123456789" + +echo "\n"; + +$wheels = ['bicycle' => 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 + */ + +<?php +// Le PHP se trouvant dans un fichier inclus doit +// également commencer par une balise PHP. + +include 'my-file.php'; +// Le code se trouvant dans my-file.php est maintenant disponible dans +// le contexte courant. Si le fichier ne peut pas être inclus +// (ex. non trouvé), un avertissement sera émit. + +include_once 'my-file.php'; +// Si le code dans my-file.php a déjà été inclus ailleur, il ne va pas +// être inclus de nouveau. + +require 'my-file.php'; +require_once 'my-file.php'; +// Même comportement que include() mais déclenche une érreur fatale si le fichier ne peux pas être inclus. + +// Contenu de my-include.php: +<?php + +return 'Anything you like.'; +// Fin de my-include.php + +// include() et require() peuvent également retourner une valeur +$value = include('my-include.php'); + +// Les fichiers sont inclus depuis le chemin donné ou, si aucun chemin n'est donné, +// la configuration 'include_path'. Si le fichier n'est pas trouvé dans le 'include_path', +// include va finalement vérifier dans le répertoire courant avant d'échouer. + +/******************************** + * Classes + */ + +// Les classes sont définies avec le mot clé 'class' + +class MyClass +{ + const MY_CONST = 'value'; // Une constante + + static $staticVar = 'static'; + + // Variables statiques et leur visibilité + public static $publicStaticVar = 'publicStatic'; + // Accessible à l'intérieur de la classe seulement + private static $privateStaticVar = 'privateStatic'; + // Accessible à l'intérieur de la classe et des classes enfants + protected static $protectedStaticVar = 'protectedStatic'; + + // Les attributs doivent définir leur visibilité + public $property = 'public'; + public $instanceProp; + protected $prot = 'protected'; + private $priv = 'private'; + + // Déclaration d'un constructeur avec __construct + public function __construct($instanceProp) { + // Access instance variables with $this + $this->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 + +<?php + +// Par défaut, les classes existent dans l'espace de nom global et peuvent +// être appelé explicitement avec un antislash. + +$cls = new \MyClass(); + + + +// On peut spécifier l'espace de nom d'un fichier comme cela +namespace My\Namespace; + +class MyClass +{ +} + +// (depuis un autre fichier...) +$cls = new My\Namespace\MyClass; + +// Ou depuis un autre espace de nom +namespace My\Other\Namespace; + +use My\Namespace\MyClass; + +$cls = new MyClass(); + +// On peut également utiliser un alias sur un espace de nom + +namespace My\Other\Namespace; + +use My\Namespace as SomeOtherNamespace; + +$cls = new SomeOtherNamespace\MyClass(); + +*/ + +``` + +## Pour plus d'informations + +Visitez la [documentation officielle](http://www.php.net/manual/fr). + +Si vous êtes intéressé par les bonnes pratiques, visitez +[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement). + +Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez +[Composer](http://getcomposer.org/). + +Pour consulter les standards, visitez "the PHP Framework Interoperability Groups" +[PSR standards](https://github.com/php-fig/fig-standards). diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown new file mode 100644 index 00000000..3f6dcabb --- /dev/null +++ b/fr-fr/python-fr.html.markdown @@ -0,0 +1,489 @@ +--- +language: python +filename: learnpython-fr.py +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Sylvain Zyssman", "https://github.com/sylzys"] + - ["Nami-Doc", "https://github.com/Nami-Doc"] +lang: fr-fr +--- + +Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires. +Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiquement du pseudo-code exécutable. + +Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service] + +NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x +Vous pourrez bientôt trouver un article pour Python 3 en Français. Pour le moment vous pouvez jettez un coup d'oeil à l'article [Python 3 en Anglais](http://learnxinyminutes.com/docs/python3/). + +```python +# Une ligne simple de commentaire commence par un dièse +""" Les lignes de commentaires multipes peuvent être écrites + en utilisant 3 guillemets ("), et sont souvent utilisées + pour les commentaires +""" + +#################################################### +## 1. Types Primaires et Opérateurs +#################################################### + +# Les nombres +3 #=> 3 + +# Les calculs produisent les résultats mathématiques escomptés +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# La division est un peu spéciale. C'est une division d'entiers, et Python arrondi le résultat par défaut automatiquement. +5 / 2 #=> 2 + +# Pour corriger ce problème, on utilise les float. +2.0 # Voici un float +11.0 / 4.0 #=> 2.75 ahhh... beaucoup mieux + +# Forcer la priorité avec les parenthèses +(1 + 3) * 2 #=> 8 + +# Les valeurs booléenes sont de type primitif +True +False + +# Pour la négation, on utilise "not" +not True #=> False +not False #=> True + +# Pour l'égalité, == +1 == 1 #=> True +2 == 1 #=> False + +# L'inégalité est symbolisée par != +1 != 1 #=> False +2 != 1 #=> True + +# D'autres comparateurs +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# On peut enchaîner les comparateurs ! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Les chaînes de caractères sont créées avec " ou ' +"C'est une chaîne." +'C\'est aussi une chaîne.' + +# On peut aussi les "additioner" ! +"Hello " + "world!" #=> "Hello world!" + +# Une chaîne peut être traitée comme une liste de caractères +"C'est une chaîne"[0] #=> 'C' + +# % peut être utilisé pour formatter des chaîne, comme ceci: +"%s can be %s" % ("strings", "interpolated") + +# Une autre manière de formatter les chaînes de caractères est d'utiliser la méthode 'format' +# C'est la méthode à privilégier +"{0} peut être {1}".format("La chaîne", "formattée") +# On peut utiliser des mot-clés au lieu des chiffres. +"{name} veut manger des {food}".format(name="Bob", food="lasagnes") + +# None est un objet +None #=> None + +# Ne pas utiliser le symbole d'inégalité "==" pour comparer des objet à None +# Il faut utiliser "is" +"etc" is None #=> False +None is None #=> True + +# L'opérateur 'is' teste l'identité de l'objet. +# Ce n'est pas très utilisé avec les types primitifs, mais cela peut être très utile +# lorsque l'on utilise des objets. + +# None, 0, et les chaînes de caractères vides valent False. +# Toutes les autres valeurs valent True +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variables et Collections +#################################################### + +# Afficher du texte, c'est facile +print "Je suis Python. Enchanté!" + + +# Il n'y a pas besoin de déclarer les variables avant de les assigner. +some_var = 5 # La convention veut que l'on utilise des minuscules_avec_underscores +some_var #=> 5 + +# Accéder à une variable non assignée lève une exception +# Voyez les structures de contrôle pour en apprendre plus sur la gestion des exceptions. +some_other_var # Lève une exception + +# 'if' peut être utilisé comme expression +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listes +li = [] +# On peut remplir liste dès l'instanciation +other_li = [4, 5, 6] + +# On ajoute des éléments avec 'append' +li.append(1) #li contient [1] +li.append(2) #li contient [1, 2] +li.append(4) #li contient [1, 2, 4] +li.append(3) #li contient [1, 2, 4, 3] + +# Et on les supprime avec 'pop' +li.pop() #=> 3 et li contient [1, 2, 4] +# Remettons-le dans la liste +li.append(3) # li contient [1, 2, 4, 3] de nouveau. + +# On accède aux éléments d'une liste comme à ceux un tableau. +li[0] #=> 1 +# Le dernier élément +li[-1] #=> 3 + +# Accèder aux indices hors limite lève une exception +li[4] # Lève un 'IndexError' + +# On peut accèder à des rangs de valeurs avec la syntaxe "slice" +# (C'est un rang de type 'fermé/ouvert' pour les plus matheux) +li[1:3] #=> [2, 4] +# Sans spécifier de fin de rang, on "saute" le début de la liste +li[2:] #=> [4, 3] +# Sans spécifier de début de rang, on "saute" la fin de la liste +li[:3] #=> [1, 2, 4] + +# Retirer un élément spécifique dee la liste avec "del" +del li[2] # li contient [1, 2, 3] + +# On peut additionner des listes entre elles +li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li et other_li existent toujours à part entière + +# Concaténer des listes avec "extend()" +li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6] + +# Vérifier l'existence d'un élément dans une liste avec "in" +1 in li #=> True + +# Récupérer la longueur avec "len()" +len(li) #=> 6 + + +# Les "tuples" sont comme des listes, mais sont immuables. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Lève un 'TypeError' + +# Mais vous pouvez faire tout ceci sur les tuples: +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Vous pouvez "dé-packager" les tuples (ou les listes) dans des variables +a, b, c = (1, 2, 3) # a vaut maintenant 1, b vaut maintenant 2 and c vaut maintenant 3 +# Sans parenthèses, un tuple est créé par défaut +d, e, f = 4, 5, 6 +# Voyez maintenant comme il est facile d'inverser 2 valeurs +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionnaires +empty_dict = {} +# Un dictionnaire pré-rempli +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Trouver des valeurs avec [] +filled_dict["one"] #=> 1 + +# Récupérer toutes les clés sous forme de liste avec "keys()" +filled_dict.keys() #=> ["three", "two", "one"] +# Note - l'ordre des clés du dictionnaire n'est pas garanti. +# Vos résultats peuvent différer de ceux ci-dessus. + +# Récupérer toutes les valeurs sous forme de liste avec "values()" +filled_dict.values() #=> [3, 2, 1] +# Note - Même remarque qu'au-dessus concernant l'ordre des valeurs. + +# Vérifier l'existence d'une clé dans le dictionnaire avec "in" +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Chercher une clé non existante lève une 'KeyError' +filled_dict["four"] # KeyError + +# Utiliser la méthode "get()" pour éviter 'KeyError' +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# La méthode get() prend un argument par défaut quand la valeur est inexistante +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# La méthode "setdefault()" permet d'ajouter de manière sécuris une paire clé-valeur dans le dictionnnaire +filled_dict.setdefault("five", 5) #filled_dict["five"] vaut 5 +filled_dict.setdefault("five", 6) #filled_dict["five"] is toujours 5 + + +# Les sets stockent ... des sets +empty_set = set() +# On initialise un "set()" avec tout un tas de valeurs +some_set = set([1,2,2,3,4]) # some_set vaut maintenant set([1, 2, 3, 4]) + +# Depuis Python 2.7, {} peut être utilisé pour déclarer un 'set' +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Ajouter plus d'éléments au set +filled_set.add(5) # filled_set contient maintenant {1, 2, 3, 4, 5} + +# Intersection de sets avec & +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Union de sets avec | +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Différence de sets avec - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Vérifier l'existence d'une valeur dans un set avec "in" +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Structure de contrôle +#################################################### + +# Initialisons une variable +some_var = 5 + +# Voici une condition 'if'. L'indentation est significative en Python ! +# Affiche "some_var est inférieur à 10" +if some_var > 10: + print "some_var est supérieur à 10." +elif some_var < 10: # La clause elif est optionnelle + print "some_var iinférieur à 10." +else: # La clause else également + print "some_var vaut 10." + + +""" +Les boucles "for" permettent d'itérer sur les listes +Affiche: + chien : mammifère + chat : mammifère + souris : mammifère +""" +for animal in ["chien", "chat", "souris"]: + # On peut utiliser % pour l'interpolation des chaînes formattées + print "%s : mammifère" % animal + +""" +"range(number)" retourne une liste de nombres +de 0 au nombre donné +Affiche: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +Les boucles "while" boucle jusqu'à ce que leur condition ne soit plus vraie +Affiche: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Raccourci pour x = x + 1 + +# Gérer les exceptions avec un bloc try/except + +# Fonctionne pour Python 2.6 et ultérieur: +try: + # Utiliser "raise" pour lever une exception + raise IndexError("This is an index error") +except IndexError as e: + pass # Pass ne prend pas d'arguments. Généralement, on gère l'erreur ici. + + +#################################################### +## 4. Fonctions +#################################################### + +# Utiliser "def" pour créer une nouvelle fonction +def add(x, y): + print "x vaut %s et y vaur %s" % (x, y) + return x + y # Renvoi de valeur avec 'return' + +# Appeller une fonction avec des paramètres +add(5, 6) #=> Affichet "x is 5 et y vaut 6" et renvoie 11 + +# Une autre manière d'appeller une fonction, avec les arguments +add(y=6, x=5) # Les arguments peuvent venir dans n'importe quel ordre. + +# On peut définir une foncion qui prend un nombre variable de paramètres +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# On peut également définir une fonction qui prend un nombre +# variable d'arguments +def keyword_args(**kwargs): + return kwargs + +# Appelons-là et voyons ce qu'il se passe +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# On peut faire les deux à la fois si on le souhaite +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) affiche: + (1, 2) + {"a": 3, "b": 4} +""" + +# En appellant les fonctions, on peut faire l'inverse des paramètres / arguments ! +# Utiliser * pour développer les paramètres, et ** pour développer les arguments +params = (1, 2, 3, 4) +args = {"a": 3, "b": 4} +all_the_args(*args) # equivaut à foo(1, 2, 3, 4) +all_the_args(**kwargs) # equivaut à foo(a=3, b=4) +all_the_args(*args, **kwargs) # equivaut à foo(1, 2, 3, 4, a=3, b=4) + +# Python a des fonctions de première classe +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Mais également des fonctions anonymes +(lambda x: x > 2)(3) #=> True + +# On trouve aussi des fonctions intégrées plus évoluées +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# On peut utiliser la syntaxe des liste pour construire les "maps" et les "filters" +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Classes +#################################################### + +# Une classe est un objet +class Human(object): + + # Un attribut de classe. Il est partagé par toutes les instances de cette classe. + species = "H. sapiens" + + # Initialiseur basique + def __init__(self, name): + # Assigne le paramètre à l'attribut de l'instance de classe. + self.name = name + + # Une méthode de l'instance. Toutes les méthodes prennent "self" comme 1er paramètre. + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Une méthode de classe est partagée par toutes les instances. + # On les appelle avec le nom de la classe en premier paramètre + @classmethod + def get_species(cls): + return cls.species + + # Une méthode statique est appellée sans référence à une classe ou à une instance + @staticmethod + def grunt(): + return "*grunt*" + + +# Instancier une classe +i = Human(name="Ian") +print i.say("hi") # Affiche "Ian: hi" + +j = Human("Joel") +print j.say("hello") #Affiche "Joel: hello" + +# Appeller notre méthode de classe +i.get_species() #=> "H. sapiens" + +# Changer les attributs partagés +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Appeller la méthode statique +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Modules +#################################################### + +# On peut importer des modules +import math +print math.sqrt(16) #=> 4 + +# Et récupérer des fonctions spécifiques d'un module +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Récuperer toutes les fonctions d'un module +# Attention, ce n'est pas recommandé. +from math import * + +# On peut raccourcir le nom d'un module +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Les modules Python sont juste des fichiers Python ordinaires. +# On peut écrire ses propres modules et les importer. +# Le nom du module doit être le même que le nom du fichier. + +# On peut trouver quelle fonction et attributs déterminent un module +import math +dir(math) + + +``` + +## Prêt à aller plus loin? + +### En ligne gratuitement + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Format papier + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown new file mode 100644 index 00000000..7d30a48d --- /dev/null +++ b/fr-fr/r-fr.html.markdown @@ -0,0 +1,747 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +filename: learnr-fr.r +lang: fr-fr +--- + +R est un langage de programmation statistique. Il dispose de nombreuses +bibliothèques pour le téléchargement et le nettoyage d'ensembles de données, +l'exécution de procédures statistiques, et la réalisation de graphiques. +On peut également exécuter des commmandes `R` au sein d'un document LaTeX. + + +```r + +# Les commentaires commencent avec des symboles numériques. + +# Il n'est pas possible de faire des commentaires multilignes, +# mais on peut placer plusieurs commentaires les uns en dessous +# des autres comme ceci. + +# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne +# et sur Windows taper CTRL-ENTER + + + +######################################################################## +# Les choses que vous pouvez faire sans rien comprendre +# à la programmation +######################################################################## + +# Dans cette section, nous vous montrons quelques trucs cools que vous +# pouvez faire avec R sans rien comprendre à la programmation. +# Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait. +# Profitez simplement ! + +data() # parcours les ensembles de données préchargées +data(rivers) # récupère ceci : "Lengths of Major North American Rivers" +ls() # notez que "rivers" apparaît maintenant dans votre espace de travail +head(rivers) # donne un aperçu des données +# 735 320 325 392 524 450 + +length(rivers) # Combien de rivers ont été mesurées ? +# 141 +summary(rivers) # Quelles sont les principales données statistiques ? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + +# Fait un diagramme à tiges et à feuilles (visualisation de données de +# types histogramme) +stem(rivers) + + +# Le point décimal est de 2 chiffres à droite du | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + +stem(log(rivers)) # Notez que les données ne sont ni normales +# ni lognormales ! +# Prenez-ça, la courbe en cloche + +# Le point décimal est à 1 chiffre à gauche du | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# Fait un histogramme : +hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres +hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard + +# Ici d'autres données qui viennent préchargées. R en a des tonnes. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + +# Plutôt que de laisser l'ordre par défaut (par année) +# Nous pourrions aussi trier pour voir ce qu'il y a de typique +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) +# +# Le point décimale est à la | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + +# Lance un dé plusieurs fois +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# Vos numéros diffèreront des miens à moins que nous mettions +# le même random.seed(31337) + +# Dessine à partir d'une normale Gaussienne 9 fois +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +############################################################## +# les types de données et l'arithmétique de base +############################################################## + +# Maintenant pour la partie orientée programmation du tutoriel. +# Dans cette section vous rencontrerez les types de données importants de R : +# les entiers, les numériques, les caractères, les logiques, et les facteurs. + +# LES ENTIERS +# Les entiers de type long sont écrits avec L +5L # 5 +class(5L) # "integer" +# (Essayez ?class pour plus d'informations sur la fonction class().) +# Avec R, chaque valeur seule, comme 5L, est considérée comme +# un vecteur de longueur 1 +length(5L) # 1 +# On peut avoir un vecteur d'entiers avec une longueur > 1 : +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + +# LES NUMÉRIQUES +# Un "numeric" est un nombre à virgule flottante d'une précision double +5 # 5 +class(5) # "numeric" +# Encore une fois, tout dans R est un vecteur ; +# Vous pouvez faire un vecteur numérique avec plus d'un élément +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# Vous pouvez aussi utiliser la notation scientifique +5e4 # 50000 +6.02e23 # nombre d'Avogadro +1.6e-35 # longueur de Planck +# Vous pouvez également avoir des nombres infiniments grands ou petits +class(Inf) # "numeric" +class(-Inf) # "numeric" +# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); +# Ça permet d'éviter de réaliser une table de la loi normale. + +# ARITHMÉTIQUES DE BASE +# Vous pouvez faire de l'arithmétique avec des nombres +# Faire des opérations arithmétiques en mixant des entiers +# et des numériques +# donne un autre numérique +10L + 66L # 76 # un entier plus un entier donne un entier +53.2 - 4 # 49.2 # un numérique moins un numérique donne un numérique +2.0 * 2L # 4 # un numérique multiplié par un entier donne un numérique +3L / 4 # 0.75 # un entier sur un numérique donne un numérique +3 %% 2 # 1 # le reste de deux numériques est un autre numérique +# Les opérations arithmétiques illégales donnent un "Not A Number" : +0 / 0 # NaN +class(NaN) # "numeric" +# Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une +# longueur plus grande que 1, à condition que la longueur du plus grand +# vecteur soit un multiple entier du plus petit +c(1,2,3) + c(1,2,3) # 2 4 6 + +# LES CARACTÈRES +# Il n'y a pas de différences entre les chaînes de caractères et +# les caractères en R +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# Ceux-ci sont tous les deux des vecteurs de longueur 1 +# Ici un plus long : +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# => +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères : +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# R possède plusieurs vecteurs de caractères préconstruits : +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + +# LES TYPES BOOLÉENS +# En R, un "logical" est un booléen +class(TRUE) # "logical" +class(FALSE) # "logical" +# Leur comportement est normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# Les données manquantes (NA) sont logiques également +class(NA) # "logical" +# On utilise | et & pour les operations logiques. +# OR +TRUE | FALSE # TRUE +# AND +TRUE & FALSE # FALSE +# Vous pouvez tester si x est TRUE +isTRUE(TRUE) # TRUE +# Ici nous avons un vecteur de type logique avec plusieurs éléments : +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE + +# LES FACTEURS +# Les facteurs sont généralement utilisés pour y stocker des +# variables qualitatives (catégorielles). +# Les facteurs peuvent être ordonnés (comme le niveau scolaire +# des enfants) ou non ordonnés (comme le sexe) +factor(c("female", "female", "male", NA, "female")) +# female female male <NA> female +# Les niveaux : female male +# Les facteurs possèdent un attribut appelé niveau ("level"). +# Les niveaux sont des vecteurs contenant toutes les valeurs +# que peuvent prendre les données catégorielles. +# Notez que les données manquantes n'entrent pas dans le niveau +levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" +# Si le vecteur de facteurs a une longueur 1, ses niveaux seront +# de longueur 1 également +length(factor("male")) # 1 +length(levels(factor("male"))) # 1 +# On rencontre communément des facteurs dans des "data frame", +# un type de données que nous couvrirons plus tard +data(infert) # "Infertility after Spontaneous and Induced Abortion" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + +# NULL +# "NULL" est bizarre ; on l'utilise pour effacer un vecteur +class(NULL) # NULL +parakeet = c("beak", "feathers", "wings", "eyes") +parakeet +# => +# [1] "beak" "feathers" "wings" "eyes" +parakeet <- NULL +parakeet +# => +# NULL + +# LES CONVERSIONS DE TYPES +# Les conversions de types servent à forcer une valeur à prendre +# un type différent +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# Si vous mettez des éléments de différents types dans un vecteur, +# des coercitions bizarres se produisent : +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Message d'avertissement : +# NAs est introduit par coercition + +# Notez également : ce n'étaient que des types de données basiques +# Il y a beaucoup d'autres types de données, comme les dates, +# les séries temporelles, etc ... + + + +####################################### +# Variables, boucles , if/else +####################################### + +# Une variable est comme une boîte dans laquelle on garde une valeur +# pour l'utiliser plus tard. +# Nous appellons ça "assigner" une valeur à une variable. +# Avoir des variables nous permet d'écrire des boucles, des fonctions, et +# des instructions conditionnelles (if/else) + +# LES VARIABLES +# Beaucoup de façons d'assigner des choses : +x = 5 # c'est correct +y <- "1" # c'est préféré +TRUE -> z # ça marche mais c'est bizarre + +# LES BOUCLES +# Il y a les boucles for : +for (i in 1:4) { + print(i) +} +# Il y a les boucles while : +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} +# Gardez à l'esprit que les boucles for et while s'exécutent lentement +# en R. +# Des opérations sur la totalité d'un vecteur (ex une ligne entière, +# une colonne entière), +# ou les fonctions de type apply() (nous en parlerons plus tard), +# sont préférées. + +# IF/ELSE +# Encore une fois assez standard +if (4 > 3) { + print("4 is greater than 3") +} else { + print("4 is not greater than 3") +} +# => +# [1] "4 is greater than 3" + +# LES FONCTIONS +# se définissent comme ceci : +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) # ajoute un peu de bruit (contrôlé) + return(x) +} +# Appelées comme n'importe quelles autres fonction R : +jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 + + + +########################################################################## +# Les structures de données : les vecteurs, les matrices, +# les data frames et les tableaux +########################################################################## + +# À UNE DIMENSION + +# Commençons par le tout début, et avec quelque chose que +# vous connaissez déjà : les vecteurs. +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# Nous demandons des éléments spécifiques en les mettant entre crochets +# (Notez que R commence à compter à partir de 1) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 +# Nous pouvons également rechercher des indices de composants spécifiques, +which(vec %% 2 == 0) # 1 3 +# Récupèrer seulement les premières ou dernières entrées du vecteur, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ou vérifier si un certaine valeur est dans le vecteur +any(vec == 10) # TRUE +# Si un index "dépasse" vous obtiendrez NA : +vec[6] # NA +# Vous pouvez trouver la longueur de votre vecteur avec length() +length(vec) # 4 +# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des +# sous-ensembles de vecteurs +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs : +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Quelques fonctions préconstruites sympas supplémentaires : +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE) + +# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci : +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Différemment du vecteur, la classe d'une matrice est "matrix", +# peut importe ce qu'elle contient +class(mat) # => "matrix" +# Récupérer la première ligne +mat[1,] # 1 4 +# Réaliser une opération sur la première colonne +3 * mat[,1] # 3 6 9 +# Demander une cellule spécifique +mat[3,2] # 6 + +# Transposer la matrice entière +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# La multiplication de matrices +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + +# cbind() colle des vecteurs ensemble en colonne pour faire une matrice +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" +# [4,] "4" "dog" +class(mat2) # matrix +# Encore une fois regardez ce qui se passe ! +# Parce que les matrices peuvent contenir des entrées de toutes sortes de +# classes, tout sera converti en classe caractère +c(class(mat2[,1]), class(mat2[,2])) + +# rbind() colle des vecteurs ensemble par lignes pour faire une matrice +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux. + +# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES) + +# Pour des colonnes de différents types, utiliser une data frame +# Cette structure de données est si utile pour la programmation statistique, +# qu'une version a été ajoutée à Python dans le paquet "pandas". + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") # name the columns +class(students) # "data.frame" +students +# => +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# Trouver les dimensions +nrow(students) # 6 +ncol(students) # 3 +dim(students) # 6 3 +# La fonction data.frame() convertit les vecteurs caractères en vecteurs de +# facteurs par défaut; désactiver cette fonction en règlant +# stringsAsFactors = FALSE quand vous créer la data.frame +?data.frame + +# Il y a plusieurs façons de subdiviser les data frames, +# toutes subtilement différentes +students$year # 3 2 2 1 0 -1 +students[,2] # 3 2 2 1 0 -1 +students[,"year"] # 3 2 2 1 0 -1 + +# Une version améliorée de la structure data.frame est data.table. +# Si vous travaillez avec des données volumineuses ou des panels, ou avez +# besoin de fusionner quelques ensembles de données, data.table peut être +# un bon choix. Ici un tour éclair : +install.packages("data.table") # télécharge le paquet depuis CRAN +require(data.table) # le charge +students <- as.data.table(students) +students # regardez la différence à l'impression +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # obtiens les lignes avec name == "Ginny" +# => +# name year house +# 1: Ginny -1 G +students[year==2] # obtiens les lignes avec year == 2 +# => +# name year house +# 1: Fred 2 G +# 2: George 2 G +# data.table facilite la fusion entre deux ensembles de données +# Faisons une autre data.table pour fusionner students +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # merge les deux ensembles de données qui matchent "house" +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# data.table facilite le résumé des tableaux +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# Pour supprimer une colonne d'une data.frame ou data.table, +# assignez-lui la valeur NULL +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Supprimer une ligne en subdivisant +# En utilisant data.table : +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# En utilisant data.frame : +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + +# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) + +# Les arrays créent des tableaux de n dimensions. +# Tous les éléments doivent être du même type. +# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions : +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, +# DE DIFFÉRENTS TYPES) + +# Enfin, R a des listes (de vecteurs) +list1 <- list(time = 1:40) +list1$price = c(rnorm(40,.5*list1$time,4)) # random +list1 +# Vous pouvez obtenir des éléments de la liste comme ceci +list1$time # une façon +list1[["time"]] # une autre façon +list1[[1]] # encore une façon différente +# => +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur +list1$price[4] + +# Les listes ne sont pas les structures de données les plus efficaces +# à utiliser avec R ; +# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames +# Les listes sont souvent retournées par des fonctions qui effectuent +# des régressions linéaires. + +########################################## +# La famille de fonction apply() +########################################## + +# Vous vous rappelez mat ? +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X +# sur les lignes (MAR = 1) ou les colonnes (MAR = 2) +# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement +# que le ferait une boucle for ou while +apply(mat, MAR = 2, jiggle) +# => +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# D'autres fonctions : ?lapply, ?sapply + +# Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant + +# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply(). +install.packages("plyr") +require(plyr) +?plyr + + + +############################ +# Charger des données +############################ + +# "pets.csv" est un fichier sur internet +# (mais il pourrait être tout aussi facilement sur votre ordinateur) +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +pets +head(pets, 2) # first two rows +tail(pets, 1) # last row + +# Pour sauvegarder une data frame ou une matrice en fichier .csv +write.csv(pets, "pets2.csv") # to make a new .csv file +# définir le répertoire de travail avec setwd(), le récupérer avec getwd() + +# Essayez ?read.csv et ?write.csv pour plus d'informations + + + +################ +# Les tracés +################ + +# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES +# Les diagrammes de dispersion ! +plot(list1$time, list1$price, main = "fake data") +# Les régressions ! +linearModel <- lm(price ~ time, data = list1) +linearModel # sort le résultat de la régression +# Tracer une ligne de regression sur une tracé existant +abline(linearModel, col = "red") +# Obtenir une variété de diagnostiques sympas +plot(linearModel) +# Les histogrammes ! +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# Les diagrammes en bâtons ! +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + +# GGPLOT2 +# Mais ceux-ci ne sont même pas les plus jolis tracés de R +# Essayez le paquet ggplot2 pour d'avantages de graphiques +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(students, aes(x=house)) +pp + geom_histogram() +ll <- as.data.table(list1) +pp <- ggplot(ll, aes(x=time,price)) +pp + geom_point() +# ggplot2 a une documentation excellente +#(disponible sur http://docs.ggplot2.org/current/) + + + +``` + +## Comment obtenir R ? + +* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) est un autre GUI diff --git a/fr-fr/racket-fr.html.markdown b/fr-fr/racket-fr.html.markdown new file mode 100644 index 00000000..8b2420f8 --- /dev/null +++ b/fr-fr/racket-fr.html.markdown @@ -0,0 +1,628 @@ +--- +language: racket +filename: learnracket-fr.rkt +contributors: + - ["th3rac25", "https://github.com/voila"] + - ["Eli Barzilay", "https://github.com/elibarzilay"] + - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"] +translators: + - ["Xavier Nayrac", "https://github.com/lkdjiin"] +lang: fr-fr +--- + +Racket est un langage de programmation généraliste, multi-paradigme, +descendant de Lisp/Scheme. + +Les retours et commentaires sont appréciés ! Vous pouvez joindre l'auteur +original ici : +[@th3rac25](http://twitter.com/th3rac25) ou là : th3rac25 [at] [google's email +service]. Vous pouvez joindre le traducteur de ce document ici : +[@lkdjiin](http://twitter.com/lkdjiin). + +```racket +#lang racket ; défini le dialecte à utiliser. + +;;; Commentaires + +;; Une ligne de commentaire commence par un point-virgule. + +#| Un bloc de commentaires + peut tenir sur plusieurs lignes… + #| + et on peut les imbriquer ! + |# +|# + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Types de données et opérateurs primitifs +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Nombres +9999999999999999999999 ; entier +#b111 ; binaire => 7 +#o111 ; octal => 73 +#x111 ; hexadécimal => 273 +3.14 ; réel +6.02e+23 +1/2 ; rationnel +1+2i ; complexe + +;; Un appel de fonction s'écrit (f x y z ...) +;; où f est une fonction et x, y, z, ... sont des arguments. +;; Si vous voulez créer une liste littérales, utilisez ' pour +;; empécher l'évaluation de la liste. +'(+ 1 2) ; => (+ 1 2) +;; Et maintenant, un peu d'arithmétique +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(quotient 5 2) ; => 2 +(remainder 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(exact->inexact 1/3) ; => 0.3333333333333333 +(+ 1+2i 2-3i) ; => 3-1i + +;;; Booléens +#t ; pour vrai +#f ; pour faux -- Toute autre valeur que #f est vraie +(not #t) ; => #f +(and 0 #f (error "doesn't get here")) ; => #f +(or #f 0 (error "doesn't get here")) ; => 0 + +;;; Caractères +#\A ; => #\A +#\λ ; => #\λ +#\u03BB ; => #\λ + +;;; Une chaîne de caractères est un tableau de caractères de longueur +;;; fixe. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; Le backslash est le caractère d'échappement +"Foo\tbar\41\x21\u0021\a\r\n" ; Sont inclus les échappements de type C + ; et unicode +"λx:(μα.α→α).xx" ; une chaîne peut inclure de l'unicode + +;; On peut ajouter une chaîne à une autre +(string-append "Hello " "world!") ; => "Hello world!" + +;; Une chaîne peut être traitée comme une liste de caractères +(string-ref "Apple" 0) ; => #\A + +;; format est utilisé pour formatter une chaîne +(format "~a can be ~a" "strings" "formatted") + +;; L'affichage est tout simple +(printf "I'm Racket. Nice to meet you!\n") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variables +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Vous pouvez créer une variable à l'aide de define +;; Une variable peut contenir n'importe quel caractères, à l'exception +;; de : ()[]{}",'`;#|\ +(define some-var 5) +some-var ; => 5 + +;; Vous pouvez aussi utiliser des caractères unicode +(define ⊆ subset?) +(⊆ (set 3 2) (set 1 2 3)) ; => #t + +;; Accéder à une variable non-initialisée provoque une exception +; x ; => x: indéfini ... + +;; Déclaration locale : `me` est attaché à "Bob" seulement à l'intérieur +;; de (let ...) +(let ([me "Bob"]) + "Alice" + me) ; => "Bob" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Structures and Collections +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Structures +(struct dog (name breed age)) +(define my-pet + (dog "lassie" "collie" 5)) +my-pet ; => #<dog> +(dog? my-pet) ; => #t +(dog-name my-pet) ; => "lassie" + +;;; Paires (non mutable) +;; `cons` construit une paire, `car` et `cdr` extraient respectivement le +;; premier et le second élément. +(cons 1 2) ; => '(1 . 2) +(car (cons 1 2)) ; => 1 +(cdr (cons 1 2)) ; => 2 + +;;; Listes + +;; Les listes en Racket sont des structures de données de type *linked-list*, +;; produites avec des paires assemblées avec `cons` et terminée par `null` +;; (ou '()). +(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3) +;; `list` est un constructeur variadique plus commode à utiliser +(list 1 2 3) ; => '(1 2 3) +;; et un guillemet simple peut aussi être utilisé pour une liste littérale +'(1 2 3) ; => '(1 2 3) + +;; On peut toujours utiliser `cons` pour ajouter un élément au début +;; d'une liste +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; Utilisez `append` pour ajouter une liste à une autre +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; Une liste est un type très basique, il y a donc *beaucoup* de +;; fonctionnalités qui leur sont dédiées, quelques exemples : +(map add1 '(1 2 3)) ; => '(2 3 4) +(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(filter even? '(1 2 3 4)) ; => '(2 4) +(count even? '(1 2 3 4)) ; => 2 +(take '(1 2 3 4) 2) ; => '(1 2) +(drop '(1 2 3 4) 2) ; => '(3 4) + +;;; Vecteurs + +;; Un vecteur est un tableau de taille fixe +#(1 2 3) ; => '#(1 2 3) + +;; Utilisez `vector-append` pour additionner des vecteurs entre eux +(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Sets + +;; Créez un set à partir d'une liste +(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3) + +;; Ajoutez un membre avec `set-add` +;; (Fonctionnel: renvoit le set étendu, plutôt que de muter le set en entrée) +(set-add (set 1 2 3) 4) ; => (set 1 2 3 4) + +;; Retirez un membre avec `set-remove` +(set-remove (set 1 2 3) 1) ; => (set 2 3) + +;; Testez l'existence d'un membre avec `set-member?` +(set-member? (set 1 2 3) 1) ; => #t +(set-member? (set 1 2 3) 4) ; => #f + +;;; Tables de hashage + +;; Créer une table de hashage non-mutable (un exemple mutable plus loin) +(define m (hash 'a 1 'b 2 'c 3)) + +;; Retrouver une valeur +(hash-ref m 'a) ; => 1 + +;; Chercher une valeur inexistante provoque une exceptions +; (hash-ref m 'd) => no value found + +;; Vous pouvez fournir une valeur par défaut pour les clés manquantes +(hash-ref m 'd 0) ; => 0 + +;; Utilisez `hash-set` pour étendre une table de hashage non-mutable +;; (Renvoit la table étendu, plutôt que de la muter) +(define m2 (hash-set m 'd 4)) +m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3)) + +;; Rappelez-vous, ces tables de hashage sont non-mutables ! +m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' + +;; Utilisez `hash-remove` pour supprimer des clés (également fonctionnel) +(hash-remove m 'a) ; => '#hash((b . 2) (c . 3)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Fonctions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Utilisez `lambda` pour créer des fonctions. +;; Une fonction renvoie toujours la valeur de sa dernière expression. +(lambda () "Hello World") ; => #<procedure> +;; On peut aussi utiliser le caractère unicode `λ' +(λ () "Hello World") ; => même fonction + +;; Utilisez des parenthèses pour appeler toutes les fonctions, ce qui +;; inclus aussi les expressions lambda +((lambda () "Hello World")) ; => "Hello World" +((λ () "Hello World")) ; => "Hello World" + +;; Assignez une fonction à une variable +(define hello-world (lambda () "Hello World")) +(hello-world) ; => "Hello World" + +;; Vous pouvez raccourcir ceci en utilisant le sucre syntaxique pour la +;; définition de fonction : +(define (hello-world2) "Hello World") + +;; Entre les () après lambda, vous déclarez la liste des arguments de la +;; fonction +(define hello + (lambda (name) + (string-append "Hello " name))) +(hello "Steve") ; => "Hello Steve" +;; … ou alors, en utilisant le sucre syntaxique, ce qui suit est équivalent +(define (hello2 name) + (string-append "Hello " name)) + +;; Vous pouvez obtenir des fonctions variadique en utilisant `case-lambda` +(define hello3 + (case-lambda + [() "Hello World"] + [(name) (string-append "Hello " name)])) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" +;; … ou spécifier des arguments optionnels avec une valeur par défaut +(define (hello4 [name "World"]) + (string-append "Hello " name)) + +;; Les fonctions peuvent rassembler des arguments supplémentaires dans une +;; liste +(define (count-args . args) + (format "You passed ~a args: ~a" (length args) args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" +;; … ou bien avec `lambda`, sans sucre syntaxique +(define count-args2 + (lambda args + (format "You passed ~a args: ~a" (length args) args))) + +;; Vous pouvez mixer arguments réguliers et supplémentaires +(define (hello-count name . args) + (format "Hello ~a, you passed ~a extra args" name (length args))) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" +;; … sans sucre syntaxique +(define hello-count2 + (lambda (name . args) + (format "Hello ~a, you passed ~a extra args" name (length args)))) + +;; Avec des mot-clés cette fois +(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args) + (format "~a ~a, ~a extra args" g name (length args))) +(hello-k) ; => "Hello World, 0 extra args" +(hello-k 1 2 3) ; => "Hello World, 3 extra args" +(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args" +(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args" +(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6) + ; => "Hi Finn, 6 extra args" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Égalité +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Pour les nombres, utilisez `=` +(= 3 3.0) ; => #t +(= 2 1) ; => #f + +;; Pour tester l'identité des objets, utilisez `eq?` +(eq? 3 3) ; => #t +(eq? 3 3.0) ; => #f +(eq? (list 3) (list 3)) ; => #f + +;; Pour les collections, utilisez `equal?` +(equal? (list 'a 'b) (list 'a 'b)) ; => #t +(equal? (list 'a 'b) (list 'b 'a)) ; => #f + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Structures de contrôle +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Conditions + +(if #t ; expression pour le test + "this is true" ; expression si vrai + "this is false") ; expression si faux +; => "this is true" + +;; Dans les condition, toutes les valeurs non-fausses sont traitées commentaires +;; étant vraies (c'est à dire toutes sauf #f) +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'yep + +;; `cond` permet d'enchaîner une série de tests afin d'obtenir un résultat +(cond [(> 2 2) (error "wrong!")] + [(< 2 2) (error "wrong again!")] + [else 'ok]) ; => 'ok + +;;; Filtrage par motif (*pattern matching*) + +(define (fizzbuzz? n) + (match (list (remainder n 3) (remainder n 5)) + [(list 0 0) 'fizzbuzz] + [(list 0 _) 'fizz] + [(list _ 0) 'buzz] + [_ #f])) + +(fizzbuzz? 15) ; => 'fizzbuzz +(fizzbuzz? 37) ; => #f + +;;; Les boucles + +;; On peut boucler en utilisant la récursion (terminale) +(define (loop i) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) +(loop 5) ; => i=5, i=6, ... + +;; D'une manière similaire, avec un `let` nommé +(let loop ((i 0)) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) ; => i=0, i=1, ... + +;; Voir plus loin pour l'ajout d'une nouvelle forme `loop`, mais Racket +;; possède déjà une forme `for` flexible et élaborée pour les itérations +(for ([i 10]) + (printf "i=~a\n" i)) ; => i=0, i=1, ... +(for ([i (in-range 5 10)]) + (printf "i=~a\n" i)) ; => i=5, i=6, ... + +;;; Itérer sur autre chose que des nombres +;; `for` permet d'itérer sur plein de type de séquences: +;; listes, vecteurs, chaînes de caractères, sets, tables de hashage, etc + +(for ([i (in-list '(l i s t))]) + (displayln i)) + +(for ([i (in-vector #(v e c t o r))]) + (displayln i)) + +(for ([i (in-string "string")]) + (displayln i)) + +(for ([i (in-set (set 'x 'y 'z))]) + (displayln i)) + +(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))]) + (printf "key:~a value:~a\n" k v)) + +;;; Itérations plus complexes + +;; Balayage parallèle de plusieurs séquences (on stoppe sur la plus petite) +(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x 1:y 2:z + +;; Boucles imbriquées +(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z + +;; Conditions dans les boucles +(for ([i 1000] + #:when (> i 5) + #:unless (odd? i) + #:break (> i 10)) + (printf "i=~a\n" i)) +; => i=6, i=8, i=10 + +;;; Compréhensions de liste +;; Très similaires aux boucles `for` -- renvoient en plus une collection + +(for/list ([i '(1 2 3)]) + (add1 i)) ; => '(2 3 4) + +(for/list ([i '(1 2 3)] #:when (even? i)) + i) ; => '(2) + +(for/list ([i 10] [j '(x y z)]) + (list i j)) ; => '((0 x) (1 y) (2 z)) + +(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10)) + i) ; => '(6 8 10) + +(for/hash ([i '(1 2 3)]) + (values i (number->string i))) +; => '#hash((1 . "1") (2 . "2") (3 . "3")) + +;; Il y a plein d'autres fonctions natives pour collecter des données à +;; l'aide de boucles +(for/sum ([i 10]) (* i i)) ; => 285 +(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 +(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t +(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t +;; Et pour n'importe quell combinaison arbitraire, utilisez `for/fold` +(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10 +;; (Ceci peut souvent remplacer des boucles communes de style impératif) + +;;; Exceptions + +;; Pour capturer une exception, utilisez la forme `with-handlers` +(with-handlers ([exn:fail? (lambda (exn) 999)]) + (+ 1 "2")) ; => 999 +(with-handlers ([exn:break? (lambda (exn) "no time")]) + (sleep 3) + "phew") ; => "phew", but if you break it => "no time" + +;; Utilisez `raise` pour soulever une exception, ou encore n'importe quelle +;; autre valeur +(with-handlers ([number? ; capturer la valeur numérique soulevée + identity]) ; la renvoyer en tant que valeur simple + (+ 1 (raise 2))) ; => 2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutabilité +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Utilisez `set!` pour réassigner une valeur à une variable existante +(define n 5) +(set! n (add1 n)) +n ; => 6 + +;; Utilisez le mécanisme des boites (*box*) pour les valeurs explicitement +;; mutables (similaire aux pointeurs ou références dans d'autres langages) +(define n* (box 5)) +(set-box! n* (add1 (unbox n*))) +(unbox n*) ; => 6 + +;; Beaucoup de types de données en Racket sont non-mutables (paires, listes, +;; etc), certains ont à la fois une version mutable et une version +;; non-mutable (chaînes, vecteurs, tables de hashage, etc) + +;; Utilisez `vector` ou `make-vector` pour créer des vecteurs mutables +(define vec (vector 2 2 3 4)) +(define wall (make-vector 100 'bottle-of-beer)) +;; Utilisez `vector-set!` pour mettre à jour un emplacement +(vector-set! vec 0 1) +(vector-set! wall 99 'down) +vec ; => #(1 2 3 4) + +;; Créer une table de hashage mutable vide et la manipuler +(define m3 (make-hash)) +(hash-set! m3 'a 1) +(hash-set! m3 'b 2) +(hash-set! m3 'c 3) +(hash-ref m3 'a) ; => 1 +(hash-ref m3 'd 0) ; => 0 +(hash-remove! m3 'a) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Modules +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Les modules permettent d'organiser le code en plusieurs fichiers +;; et bibliothèques réutilisables. Ici, nous utiliserons des sous-modules, +;; imbriqués dans le grand module que forme ce texte (qui démarre à la +;; ligne `#lang`). + +(module cake racket/base ; défini un module `cake', basé sur racket/base + + (provide print-cake) ; fonction exportée par le module (publique) + + (define (print-cake n) + (show " ~a " n #\.) + (show " .-~a-. " n #\|) + (show " | ~a | " n #\space) + (show "---~a---" n #\-)) + + (define (show fmt n ch) ; fonction interne/privée + (printf fmt (make-string n ch)) + (newline))) + +;; Utilisez `require` pour importer les fonctions fournies par un +;; module (provide) +(require 'cake) ; le ' est pour un sous-module local +(print-cake 3) +; (show "~a" 1 #\A) ; => erreur, `show` n'est pas exportée + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. Classes et objets +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Créer une classe fish% (% est idiomatique pour les noms de classes) +(define fish% + (class object% + (init size) ; argument pour l'initialisation + (super-new) ; initialisation de la super-classe + ;; Les champs/membres/variables de classe + (define current-size size) + ;; Méthodes publiques + (define/public (get-size) + current-size) + (define/public (grow amt) + (set! current-size (+ amt current-size))) + (define/public (eat other-fish) + (grow (send other-fish get-size))))) + +;; Créer une instance de fish% +(define charlie + (new fish% [size 10])) + +;; Utilisez `send` pour appeler une méthode d'un objet +(send charlie get-size) ; => 10 +(send charlie grow 6) +(send charlie get-size) ; => 16 + +;; `fish%` est une simple valeur de «première classe», ce qui va permettre +;; la composition (*mixins*) +(define (add-color c%) + (class c% + (init color) + (super-new) + (define my-color color) + (define/public (get-color) my-color))) +(define colored-fish% (add-color fish%)) +(define charlie2 (new colored-fish% [size 10] [color 'red])) +(send charlie2 get-color) +;; ou, sans les noms: +(send (new (add-color fish%) [size 10] [color 'red]) get-color) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 9. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Les macros permettent d'étendre la syntaxe du langage + +;; Ajoutons une boucle `loop` +(define-syntax-rule (while condition body ...) + (let loop () + (when condition + body ... + (loop)))) + +(let ([i 0]) + (while (< i 10) + (displayln i) + (set! i (add1 i)))) + +;; Les macros sont hygiéniques, vous ne pouvez pas *clasher* avec les +;; variables existantes ! +(define-syntax-rule (swap! x y) ; ! est idiomatique pour la mutation + (let ([tmp x]) + (set! x y) + (set! y tmp))) + +(define tmp 2) +(define other 3) +(swap! tmp other) +(printf "tmp = ~a; other = ~a\n" tmp other) +;; La variable `tmp` est renommée en `tmp_1` +;; dans le but d'éviter un conflit de nom +;; (let ([tmp_1 tmp]) +;; (set! tmp other) +;; (set! other tmp_1)) + +;; Mais il faut quand même faire bien attention avec les macros, par exemple: +(define-syntax-rule (bad-while condition body ...) + (when condition + body ... + (bad-while condition body ...))) +;; cette macro est cassée : ell génère un code infini, si vous l'essayez +;; le compilateur va entrer dans une boucle infinie. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 10. Contrats +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Les contrats imposent des contraintes aux valeurs exportées depuis +;; les modules + +(module bank-account racket + (provide (contract-out + [deposit (-> positive? any)] ; un dépot est toujours positif + [balance (-> positive?)])) + + (define amount 0) + (define (deposit a) (set! amount (+ amount a))) + (define (balance) amount) + ) + +(require 'bank-account) +(deposit 5) + +(balance) ; => 5 + +;; Les clients qui essaient de déposer un montant non-positif sont blamés +;; (deposit -5) ; => deposit: contract violation +;; expected: positive? +;; given: -5 +;; more details.... +``` + +## Pour aller plus loin + +Vous en voulez plus ? Essayez +[Getting Started with Racket](http://docs.racket-lang.org/getting-started/) diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown new file mode 100644 index 00000000..1564d2b6 --- /dev/null +++ b/fr-fr/ruby-fr.html.markdown @@ -0,0 +1,411 @@ +--- +language: ruby +filename: learnruby-fr.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] +translators: + - ["Geoffrey Roguelon", "https://github.com/GRoguelon"] + - ["Nami-Doc", "https://github.com/Nami-Doc"] +lang: fr-fr +--- + +```ruby +# Ceci est un commentaire + +=begin +Ceci est un commentaire multiligne +Personne ne les utilise +Vous devriez en faire de même +=end + +# Tout d'abord : Tout est un objet. + +# Les nombres sont des objets + +3.class #=> Fixnum + +3.to_s #=> "3" + +# Les opérateurs de base +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Les opérateurs sont juste des raccourcis +# pour appeler une méthode sur un objet +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Les valeurs spéciales sont des objets +nil # Nul +true # Vrai +false # Faux + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Égalité +1 == 1 #=> true +2 == 1 #=> false + +# Inégalité +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# à part false lui-même, nil est la seule autre valeur 'false' + +!nil #=> true +!false #=> true +!0 #=> false + +# Plus de comparaisons +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Les chaînes de caractères sont des objets + +'Je suis une chaîne de caractères'.class #=> String +"Je suis également une chaîne de caractères".class #=> String + +placeholder = "utiliser l'interpolation de chaîne de caractères" +"Je peux #{placeholder} quand j'utilise les guillemets" +#=> "Je peux utiliser l'interpolation de chaîne de caractères quand j'utilise les guillemets" + +# Affichez un message +puts "J'affiche à l'écran!" + +# Variables +x = 25 #=> 25 +x #=> 25 + +# Notez que l'affectation retourne la valeur affectée. +# Cela signifie que vous pouvez affecter plusieurs fois de suite : + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Par convention, utilisez la notation underscore +# pour nommer les variables +snake_case = true + +# Utilisez des noms de variable explicites +path_to_project_root = '/nom/correct/' +path = '/mauvais/nom/' + +# Symboles (aussi des objets) +# Les symboles sont immuables, constants, +# réutilisables et représentés en interne +# par une valeur entière. Ils sont souvent +# utilisés à la place des chaînes de caractères +# pour transmettre efficacement des valeurs +# spécifiques ou significatives + +:pending.class #=> Symbol + +status = :pending + +status == :pending #=> true + +status == 'pending' #=> false + +status == :approved #=> false + +# Tableaux + +# Ceci est un tableau +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Les tableaux contiennent différents types d'élément. + +[1, "hello", false] #=> [1, "hello", false] + +# Les tableaux peuvent être indexés +# Du début +array[0] #=> 1 +array[12] #=> nil + +# Comme les opérateurs, la syntaxe [var] est juste un raccourci +# pour appeler la méthode [] d'un objet +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# Depuis la fin +array[-1] #=> 5 + +# Avec un index de début et de fin +array[2, 4] #=> [3, 4, 5] + +# Ou avec un intervalle +array[1..3] #=> [2, 3, 4] + +# Ajoutez un élément au tableau comme ceci +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# Les Hash sont des dictionnaires Ruby contenant des paires de clé/valeur. +# Les Hash sont délimitées par des accolades : +hash = {'color' => 'green', 'number' => 5} + +hash.keys #=> ['color', 'number'] + +# Les Hash retournent la valeur +# en utilisant la clé associée à la valeur : +hash['color'] #=> 'green' +hash['number'] #=> 5 + +# Recherchez une clé inexistante dans une Hash retourne nil : +hash['nothing here'] #=> nil + +# Depuis Ruby 1.9, Une syntaxe spécifique est apparue +# en utilisant les symboles comme clés : + +new_hash = { defcon: 3, action: true} + +new_hash.keys #=> [:defcon, :action] + +# Astuce : Les tableaux et les Hash sont dénombrables +# Ils partagent un certain nombre de méthodes pratiques +# telle que each, map, count, etc... + +# Structures de contrôle + +if true + "si instruction" +elsif false + "autrement si, facultatif" +else + "autrement, également facultatif" +end + +for compteur in 1..5 + puts "itération #{compteur}" +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +# CEPENDANT, l'usage de la boucle for est très rare. +# À la place, utilisez la méthode "each" +# et passez lui un bloc de code. +# Un bloc de code est un ensemble d'instructions +# que vous pouvez passer à une methode comme "each". +# Les blocs sont similaires aux lambdas, aux fonctions anonymes +# ou encore aux closures dans d'autres langages. +# +# La méthode "each" exécute le bloc de code +# pour chaque élément de l'intervalle d'éléments. +# Le bloc de code passe un paramètre compteur. +# Appelez la méthode "each" avec un bloc de code comme ceci : + +(1..5).each do |compteur| + puts "itération #{compteur}" +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +# Vous pouvez également mettre un bloc de code entre accolades : +(1..5).each {|compteur| puts "itération #{compteur}"} + +# Le contenu des structures de données peut être parcouru +# en utilisant la méthode each. +array.each do |element| + puts "#{element} est une partie du tableau" +end +hash.each do |cle, valeur| + puts "#{cle} est #{valeur}" +end + +compteur = 1 +while compteur <= 5 do + puts "itération #{compteur}" + compteur += 1 +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +grade = 'B' + +case grade +when 'A' + puts "Excellent" +when 'B' + puts "Plus de chance la prochaine fois" +when 'C' + puts "Vous pouvez faire mieux" +when 'D' + puts "C'est pas terrible" +when 'F' + puts "Vous avez échoué!" +else + puts "Sytème de notation alternatif" +end + +# Fonctions + +def double(x) + x * 2 +end + +# Les fonctions (et tous les blocs de code) retournent +# implicitement la valeur de la dernière instruction évaluée +double(2) #=> 4 + +# Les parenthèses sont facultatives +# lorsqu'il n'y a pas d'ambiguïté sur le résultat +double 3 #=> 6 + +double double 3 #=> 12 + +def sum(x,y) + x + y +end + +# Les paramètres de méthode sont séparés par des virgules +sum 3, 4 #=> 7 + +sum sum(3,4), 5 #=> 12 + +# yield +# Toutes les méthodes ont un argument facultatif et implicite +# de type bloc de code +# il peut être appelé avec le mot clé 'yield' + +def surround + puts "{" + yield + puts "}" +end + +surround { puts 'Bonjour tout le monde' } + +# { +# Bonjour tout le monde +# } + + +# Définissez une classe avec le mot clé 'class' +class Humain + + # Une variable de classe + # est partagée par toutes les instances de cette classe. + @@espece = "H. sapiens" + + # Constructeur de classe + def initialize(nom, age = 0) + # Affectez l'argument à la variable d'instance 'nom' + # pour la durée de vie de l'instance de cette classe + @nom = nom + # Si le paramètre 'age' est absent, + # la valeur par défaut définie dans la liste des arguments sera utilisée. + @age = age + end + + # Une simple méthode setter + def nom=(nom) + @nom = nom + end + + # Une simple méthode getter + def nom + @nom + end + + # Une méthode de classe utilise le mot clé 'self' + # pour se distinguer de la méthode d'instance. + # La méthode sera alors accessible à partir de la classe + # et non pas de l'instance. + def self.say(msg) + puts "#{msg}" + end + + def espece + @@espece + end + +end + + +# Instanciez une classe +jim = Humain.new("Jim Halpert") + +dwight = Humain.new("Dwight K. Schrute") + +# Appelez quelques méthodes +jim.espece #=> "H. sapiens" +jim.nom #=> "Jim Halpert" +jim.nom = "Jim Halpert II" #=> "Jim Halpert II" +jim.nom #=> "Jim Halpert II" +dwight.espece #=> "H. sapiens" +dwight.nom #=> "Dwight K. Schrute" + +# Appelez la méthode de classe +Humain.say("Hi") #=> "Hi" + +# Les classes sont également des objets en Ruby. +# Par conséquent, les classes peuvent avoir des variables d'instance. +# Les variables de classe sont partagées parmi +# la classe et ses descendants. + +# Classe parente +class Humain + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(valeur) + @@foo = valeur + end +end + +# Classe fille +class Travailleur < Humain +end + +Humain.foo # 0 +Travailleur.foo # 0 + +Humain.foo = 2 # 2 +Travailleur.foo # 2 + +# Les variables d'instance de classe ne sont pas partagées +# avec les classes héritées. + +class Humain + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(valeur) + @bar = valeur + end +end + +class Docteur < Humain +end + +Humain.bar # 0 +Docteur.bar # nil + +``` diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown new file mode 100644 index 00000000..a43edf16 --- /dev/null +++ b/fr-fr/scala.html.markdown @@ -0,0 +1,457 @@ +--- +language: Scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra", "http://dbousamra.github.com"] +translators: + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +filename: learnscala-fr.scala +lang: fr-fr +--- + +### Scala - le langage évolutif + +```scala + +/* + Pour vous préparer : + + 1) (Téléchargez Scala)[http://www.scala-lang.org/downloads] + 2) Dézippez/décompressez dans votre endroit préféré + et ajoutez le chemin du sous-répertoire bin au chemin du système + 3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur : + + scala> + + C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. + Vous pouvez y exécuter des commandes. + Allons-y : +*/ + +println(10) // affiche l'integer 10 + +println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo! + + +// Quelques basiques + +// Imprimer et forcer une nouvelle ligne à la prochaine impression +println("Hello world!") +// Imprimer sans forcer une nouvelle ligne à la prochaine impression +print("Hello world") + +// Pour déclarer des valeurs on utilise var ou val +// Les déclarations val sont immuables, tandis que les var sont muables. +// L'immuabilité est une bonne chose. + +val x = 10 // x vaut maintenant 10 +x = 20 // erreur : réaffectation à val +var x = 10 +x = 20 // x vaut maintenant 20 + +// Les commentaires d'une ligne commencent par deux slashs + +/* +Les commentaires multilignes ressemblent à ça. +*/ + +// les valeurs booléennes +true +false + +// Les opérateurs booléens +!true // false +!false // true +true == false // false +10 > 5 // true + +// Les opérateurs mathématiques sont habituels +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 + + +// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande + +1 + 7 + +/* Les lignes ci-dessous donnent les résultats : + + scala> 1 + 7 + res29: Int = 8 + + Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de + type Int avec une valeur de 8 + + 1+7 donnera le même résultat +*/ + + +// Tout est un objet, même une fonction. Tapez ceci dans le REPL : + +7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat) + + +// La ligne suivante est une fonction qui prend un Int et retourne son carré +(x:Int) => x * x + + +// On peut assigner cette fonction à un identifieur comme ceci : +val sq = (x:Int) => x * x + +/* La ligne suivante nous dit : + + sq: Int => Int = <function1> + + Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur. + sq est une fonction qui prend un Int et retourne un Int. + + + sq peut être exécutée comme ci-dessous : +*/ + +sq(10) // donne comme résultat : res33: Int = 100. + + +// les deux-points définissent explicitement le type de la valeur, +// dans ce cas une fonction qui prend un Int et retourne un Int. +val add10: Int => Int = _ + 10 + +// Scala autorise des méthodes et des fonctions à retourner +// ou prendre comme paramètres des autres fonctions ou méthodes + + +List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments + + +// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées : +List(1, 2, 3) map (x => x + 10) + + + + +// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre. +// Il se comporte comme une variable +List(1, 2, 3) map (_ + 10) + + + +// Si le bloc et la fonction anonyme prennent tous les deux un seul argument, +// vous pouvez omettre le tiret du bas +List("Dom", "Bob", "Natalia") foreach println + + + +// Les structures de données + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // Lance une exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // Lance une exception + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* Jetez un oeil sur la documentation de map ici - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + */ + + +// Tuples + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// Exemple d'utilisation +val divideInts = (x:Int, y:Int) => (x / y, x % y) + + +divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division + +// Pour accéder à un élément d'un tuple, utilisez _._n +// où n est l'index de base 1 de l'élément +val d = divideInts(10,3) + +d._1 + +d._2 + + + +// Des combinaisons + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + + + +// La fonction filter prend un prédicat (une fonction de type A -> Booléen) et +// sélectionne tous les éléments qui satisfont ce prédicat +List(1, 2, 3) filter (_ > 2) // List(3) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + + + +// Scala a une méthode foreach définie pour certaines collections +// qui prend en argument une fonction renvoyant Unit (une méthode void) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + + + + +// Compréhensions de listes + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + + + +/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for + est "répète", alors qu'une for-compréhension définit une relation + entre deux ensembles de données. */ + + + +// Boucles et itération + +1 to 5 +val r = 1 to 5 +r.foreach( println ) + +r foreach println +// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. +// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais. + + +(5 to 1 by -1) foreach ( println ) + +// Une boucle while +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + +while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ? + + + + + + +i // Montre la valeur de i. Notez que while est une boucle au sens classique. + // Il exécute séquentiellement pendant que la variable de boucle change. + // While est très rapide, + // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus + // facile pour comprendre et pour faire la parallélisation + +// La boucle do while +do { + println("x is still less then 10"); + x += 1 +} while (x < 10) + + +// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala. +// Les fonctions récursives ont besoin d'un type de retour explicite, +// le compilateur ne peut pas le déduire. +// Ici c'est Unit. +def showNumbersInRange(a:Int, b:Int):Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} + + + +// Structures de contrôle + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + + + +// Les caractéristiques "Orienté Objet" + +// Création d'une classe Dog +class Dog { + // Une méthode appelée bark qui retourne une chaîne de caractère + def bark: String = { + // le corps de la méthode + "Woof, woof!" + } +} + + +// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes, +// des fonctions, des méthodes, des objets, des classes case, des traits, etc ... + + + +// Les classes case + +case class Person(name:String, phoneNumber:String) + +Person("George", "1234") == Person("Kate", "1236") + + + + +// Correspondances de motifs + +val me = Person("George", "1234") + +me match { case Person(name, number) => { + "We matched someone : " + name + ", phone : " + number }} + +me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." } + +me match { case Person("George", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + +val kate = Person("Kate", "1234") + +kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + + + +// Expressions régulières + +val email = "(.*)@(.*)".r // On fait une Regex en invoquant r sur la chaîne de caractère + +val email(user, domain) = "henry@zkpr.com" + +"mrbean@pyahoo.com" match { + case email(name, domain) => "I know your name, " + name +} + + + +// Les chaînes de caractères + +"Les chaînes de caractères Scala sont entourées de doubles guillements" +'a' // Un caractère de Scala +'Les simples guillemets n'existent pas en Scala // Erreur +"Les chaînes de caractères possèdent les méthodes usuelles de Java".length +"Il y a aussi quelques méthodes extra de Scala.".reverse + +// Voir également : scala.collection.immutable.StringOps + +println("ABCDEF".length) +println("ABCDEF".substring(2, 6)) +println("ABCDEF".replace("C", "3")) + +val n = 45 +println(s"We have $n apples") + +val a = Array(11, 9, 6) +println(s"My second daughter is ${a(2-1)} years old") + +// Certains caractères ont besoin d'être "échappés", +// ex un guillemet à l'intérieur d'une chaîne de caractères : +val a = "They stood outside the \"Rose and Crown\"" + +// Les triples guillemets permettent d'écrire des chaînes de caractères +// sur plusieurs lignes et peuvent contenir des guillemets + +val html = """<form id="daform"> + <p>Press belo', Joe</p> + | <input type="submit"> + </form>""" + + + +// Structure et organisation d'une application + +// Importer des chaînes de caratères +import scala.collection.immutable.List + +// Importer tous les sous-paquets +import scala.collection.immutable._ + +// Importer plusieurs classes en une seule instruction +import scala.collection.immutable.{List, Map} + +// Renommer un import en utilisant '=>' +import scala.collection.immutable.{ List => ImmutableList } + +// Importer toutes les classes, à l'exception de certaines. +// La ligne suivante exclut Map et Set : +import scala.collection.immutable.{Map => _, Set => _, _} + +// Le point d'entrée du programme est défini dans un fichier scala +// utilisant un objet, avec une simple méthode main : +object Application { + def main(args: Array[String]): Unit = { + // Votre code ici. + } +} + +// Les fichiers peuvent contenir plusieurs classes et plusieurs objets. +// On les compile avec scalac + + + + +// Entrée et Sortie + +// Pour lire un fichier ligne par ligne +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// On utilise le PrintWriter de Java pour écrire un fichier + + +``` + +## Autres ressources + +[Scala for the impatient](http://horstmann.com/scala/) + +[Twitter Scala school](http://twitter.github.io/scala_school/) + +[The scala documentation](http://docs.scala-lang.org/) + +[Try Scala in your browser](http://scalatutorials.com/tour/) + +Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user) diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown new file mode 100644 index 00000000..b8807104 --- /dev/null +++ b/fr-fr/typescript-fr.html.markdown @@ -0,0 +1,174 @@ +--- +language: TypeScript +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +translators: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +filename: learntypescript-fr.ts +lang: fr-fr +--- + +TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. + +Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). + +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript. + +```js +// Il y a 3 types basiques en TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// Si nous ne pouvons pas déterminer le type, on utilise `Any` +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // ok, définitivement un booléen + +// Pour les collections, il y a les tableaux typés et les tableaux génériques +var list: number[] = [1, 2, 3]; // Un tableaux typé +var list: Array<number> = [1, 2, 3]; // un tableau générique + +// Pour les énumeration +enum Color { Red, Green, Blue }; +var c: Color = Color.Green; + +// Enfin, `void` est utilisé dans le cas spécifique +// d'une fonction ne retournant rien +function bigHorribleAlert(): void { + alert("Je suis une petite boîte ennuyeuse !"); +} + +// Les fonctions sont des entités de première classe. Le langage supporte +// les expressions lambda et utilise l'inférence de type + +// Les fonctions ci-dessous sont équivalentes, une signature identique +// sera inférée par le compilateur, et le même JavaScript sera généré +var f1 = function(i: number): number { return i * i; } +// Retourne un type inféré +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Retourne un type inféré +var f4 = (i: number) => { return i * i; } +// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire +var f5 = (i: number) => i * i; + +// Les interfaces sont structurées, tout les objets qui ont ces propriétés +// sont compatible avec l'interface +interface Person { + name: string; + // Les propriétés optionnelles sont identifiées avec un "?" + age?: number; + // Et bien sûr, les fonctions + move(): void; +} + +// Un objet implémentant l'interface "Person" peut être traité comme +// une Person car il a les propriétés "name" et "move" +var p: Person = { name: "Bobby", move: () => {} }; +// Des objets implémentants la propriété optionnelle : +// valide car "age" est un nombre +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// invalide car "age" n'est pas un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Les interfaces peuvent aussi décrire un type de fonction +interface SearchFunc { + (source: string, subString: string): boolean; +} + +// Seul les types des paramètres sont importants. Les noms ne le sont pas. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Les membres des classes sont publiques par défaut. +class Point { + // Propriétés + x: number; + + // Constructeur - Les mots clés "public" et "private" dans ce contexte + // génèrent le code de la propriété et son initialisation dans le + // constructeur. Ici, "y" sera défini de la même façon que "x", + // mais avec moins de code. Les valeurs par défaut sont supportées. + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Fonctions + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Membres statiques + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); // y sera 0 + +// Héritage +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + // Un appel explicite au constructeur de la super classe + // est obligatoire. + super(x, y); + } + + // Redéfinition + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Modules, "." peut être utilisé comme un séparateur de sous modules. +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Alias local pour référencer un module +import G = Geometry; + +var s2 = new G.Square(10); + +// Génériques +// Classes +class Tuple<T1, T2> { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair<T> { + item1: T; + item2: T; +} + +// Et fonctions +var pairToTuple = function<T>(p: Pair<T>) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Inclure des références à un fichier : +/// <reference path="jquery.d.ts" /> + +``` + +## Lectures complémentaires + * [Site officiel de TypeScript] (http://www.typescriptlang.org/) + * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript) + * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) diff --git a/fr-fr/xml-fr.html.markdown b/fr-fr/xml-fr.html.markdown new file mode 100644 index 00000000..ed5f55ff --- /dev/null +++ b/fr-fr/xml-fr.html.markdown @@ -0,0 +1,128 @@ +--- +language: xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Geoffrey Liu", "https://github.com/g-liu"] +filename: learnxml-fr.xml +lang: fr-fr +--- + +XML est un langage de balisage conçu pour stocker et transporter les informations. + +Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les informations, juste comment les porter. + +* La syntaxe XML + +```xml +<!-- Les commentaires en XML ressemblent ceci --> + +<?xml version="1.0" encoding="UTF-8"?> +<librairie> + <livre categorie="CUISINE"> + <titre lang="en">Everyday Italian</titre> + <auteur>Giada De Laurentiis</auteur> + <an>2005</an> + <prix>30.00</prix> + </livre> + <livre categorie="ENFANTS"> + <titre lang="en">Harry Potter</titre> + <auteur>J. K. Rowling</auteur> + <an>2005</an> + <prix>29.99</prix> + </livre> + <livre categorie="WEB"> + <titre lang="en">Learning XML</titre> + <auteur>Erik T. Ray</auteur> + <an>2003</an> + <prix>39.95</prix> + </livre> +</librairie> + +<!-- Ce qui suit est un fichier XML typique. + Il commence par une déclaration, qui informe certaines métadonnées (en option). + +XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a + trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ... + +On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre + les balises d'ouverture et de fermeture. --> + + +<!-- XML porte deux types d'informations: + 1 - Les attributs -> les métadonnées sur un nœud. + Habituellement, l'analyseur XML utilise cette information pour bien stocker les données. + 2 - Les éléments -> les informations pures. + C'est ce que l'analyseur retrouvera du fichier XML. + Les éléments apparaissent entre les balises d'ouverture et de fermeture, sans parenthèses. --> + + +<!-- Ci-dessous, un élément avec deux attributs --> +<fichier type="gif" id="4293">ordinateur.gif</fichier> + + +``` + +* Un document bien formaté & le validation + +Un document XML est bien formaté s'il est syntaxiquement correct. +Cependant, il est possible d'injecter plus de contraintes dans le document, +en utilisant les définitions de documents, tels que les schémas DTD et XML. + +Un document XML qui suit une définition de document est dit valide, +en ce qui concerne ce document. + +Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique de l'application. + +```xml + +<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie, + avec l'addition de définition DTD. --> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Librairie.dtd"> +<librairie> + <livre categorie="CUISINE"> + <titre>Everyday Italian</titre> + <prix>30.00</prix> + </livre> +</librairie> + +<!-- Cette DTD pourrait être quelque chose comme: --> + +<!DOCTYPE note +[ +<!ELEMENT librairie (livre+)> +<!ELEMENT livre (titre,prix)> +<!ATTLIST livre categorie CDATA "Littérature"> +<!ELEMENT titre (#PCDATA)> +<!ELEMENT prix (#PCDATA)> +]> + +<!-- La DTD commence par une déclaration. + Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. + Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut + appelé «catégorie», avec «littérature» comme valeur par défaut. + Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés + (Anglais: «parsed character data») --> + +<!-- La DTD pourrait être déclarée dans le fichier XML lui-même --> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT librairie (livre+)> +<!ELEMENT livre (titre,prix)> +<!ATTLIST livre categorie CDATA "Littérature"> +<!ELEMENT titre (#PCDATA)> +<!ELEMENT prix (#PCDATA)> +]> + +<librairie> + <livre categorie="CUISINE"> + <titre>Everyday Italian</titre> + <prix>30.00</prix> + </livre> +</librairie> +``` diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown new file mode 100644 index 00000000..43b1df54 --- /dev/null +++ b/fr-fr/yaml-fr.html.markdown @@ -0,0 +1,157 @@ +--- +language: yaml +filename: learnyaml.yaml +contributors: + - ["Andrei Curelaru", "http://www.infinidad.fr"] +lang: fr-fr +--- + +Proposé à l'origine par Clark Evans en Mai 2001, YAML est un un format de +représentation de données par sérialisation, conçu pour être aisément +éditable et lisible par nous même, les humains. + +YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont il est un parent naturel. Toutefois, YAML emprunte également des idées et concepts de chez Python, et s'intègre bien avec bon nombre de langages. + + +```yaml +# les Commentaires sont précédés d'un signe "#", comme cette ligne. + +############# +# SCALAIRES # +############# + +# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections +# ( listes ou tableaux associatifs ). + +# Notre objet root ( racine ), sera une map ( carte ) et englobera +# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire, +# hash ou objet dans d'autres langages. +clé: valeur +aurtre_clé: une autre valeur +valeur_numérique: 100 +notation_scientifique: 1e+12 +boolean: true +valeur_null: null +clé avec espaces: valeur +# Bien qu'il ne soit pas nécessaire d'enfermer les chaînes de caractères +# entre guillemets, cela reste possible, et parfois utile. +toutefois: "Une chaîne, peut être contenue entre guillemets." +"Une clé entre guillemets.": "Utile si on veut utiliser ':' dans la clé." + +# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix, +# comme un 'bloc littéral' ( avec | ) ou bien 'bloc replié' avec ( > ). +bloc_littéral: | + Tout ce bloc de texte sera la valeur de la clé 'bloc_littéral', + avec préservation des retours à la ligne. ( chaque ligne vide à + l'intérieur du même bloc, sera remplacée par "\n\n" ) + + Le littéral continue jusqu'à ce que l'indentation soit annulée. + + Toutes lignes qui serait "d'avantage indentées" conservent leur + indentation, constituée de 4 espaces. +bloc_replié: > + Tout ce bloc de texte sera la valeur de la clé 'bloc_replié', mais + cette fois ci, toutes les nouvelles lignes deviendront un simple espace. + + Les lignes vides, comme ci-dessus, seront converties en caractère "\n". + + Les lignes 'plus-indentées' gardent leurs retours à la ligne - + ce texte apparaîtra sur deux lignes. + +############### +# COLLECTIONS # +############### + +# l'Imbrication est créée par indentation. +une_map_imbriquée: + clé: valeur + autre_clé: autre valeur + autre_map_imbriquée: + bonjour: bonjour + +# les Clés des Maps ne sont pas nécessairement des chaînes de caractères. +0.25: une clé de type float + +# les Clés peuvent également être des objets s'étendant sur plusieurs lignes, +# en utilisant le signe "?" pour indiquer le début de la clé. +? | + ceci est une Clé + sur de multiples lignes +: et ceci est sa Valeur + +# YAML autorise aussi l'usage des collections à l'intérieur des clés, +# mais certains langages de programmation ne le tolère pas si bien. + +# les Séquences (équivalent des listes ou tableaux) ressemblent à cela: +une_séquence: + - Item 1 + - Item 2 + - 0.5 # les séquences peuvent contenir des types variés. + - Item 4 + - clé: valeur + autre_clé: autre_valeur + - + - Ceci est une séquence + - dans une autre séquence + +# YAML étant un proche parent de JSON, vous pouvez écrire directement +# des maps et séquences façon JSON +json_map: {"clé": "valeur"} +json_seq: [1, 2, 3, "soleil"] + +################################# +# AUTRES FONCTIONNALITÉES YAML # +################################# + +# YAML possède une fonctionnalité fort utile nommée 'ancres'. Celle-ci +# vous permet de dupliquer aisément du contenu au sein de votre document. + +# Les deux clés suivantes auront la même valeur: +contenu_ancré: &nom_ancre Cette chaîne sera la valeur des deux clés. +autre_ancre: *nom_ancre + +# Avec les Tags YAML, vous pouvez explicitement déclarer des types de données. +chaine_explicite: !!str 0.5 + +# Certains parsers implémentent des tags spécifiques à d'autres langages, +# comme par exemple le "complex number" de Python. +python_complex_number: !!python/complex 1+2j + +##################### +# AUTRES TYPES YAML # +##################### + +# YAML interprète également les données formatées ISO de type date et datetime, +# pas seulement les chaînes et nombres. +datetime: 2001-12-15T02:59:43.1Z +datetime_avec_espaces: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 + +# Le tag !!binary indique que la chaîne à suivre est la représentation binaire +# d'un blob encodé en base64. En clair ? Une image ! +fichier_gif: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML a de même un type "set", qui ressemble à cela: +set: + ? item1 + ? item2 + ? item3 + +# Comme dans Python, les sets ne sont que des maps contenant des valeurs null ; +# le set précédent est l'équivalent du suivant: +set2: + item1: null + item2: null + item3: null + +``` + +Quelques références et outils : + +- Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*, +- Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire, +- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples. diff --git a/fsharp.html.markdown b/fsharp.html.markdown index 49951c78..62118006 100644 --- a/fsharp.html.markdown +++ b/fsharp.html.markdown @@ -5,7 +5,7 @@ contributors: filename: learnfsharp.fs --- -F# is a general purpose functional/OO programming language. It's free and open source, and runs on Linux, Mac, Windows and more. +F# is a general purpose functional/OO programming language. It's free and open source, and runs on Linux, Mac, Windows and more. It has a powerful type system that traps many errors at compile time, but it uses type inference so that it reads more like a dynamic language. @@ -90,7 +90,7 @@ let simplePatternMatch = | _ -> printfn "x is something else" // underscore matches anything // F# doesn't allow nulls by default -- you must use an Option type -// and then pattern match. +// and then pattern match. // Some(..) and None are roughly analogous to Nullable wrappers let validValue = Some(99) let invalidValue = None @@ -115,7 +115,7 @@ printfn "A string %s, and something generic %A" "hello" [1;2;3;4] // into a string, similar to String.Format in C#. // ================================================ -// More on functions +// More on functions // ================================================ // F# is a true functional language -- functions are first @@ -124,30 +124,30 @@ printfn "A string %s, and something generic %A" "hello" [1;2;3;4] // Modules are used to group functions together // Indentation is needed for each nested module. -module FunctionExamples = +module FunctionExamples = // define a simple adding function let add x y = x + y - + // basic usage of a function let a = add 1 2 printfn "1+2 = %i" a - + // partial application to "bake in" parameters let add42 = add 42 let b = add42 1 printfn "42+1 = %i" b - + // composition to combine functions let add1 = add 1 let add2 = add 2 let add3 = add1 >> add2 let c = add3 7 printfn "3+7 = %i" c - + // higher order functions [1..10] |> List.map add3 |> printfn "new list is %A" - + // lists of functions, and more let add6 = [add1; add2; add3] |> List.reduce (>>) let d = add6 7 @@ -158,54 +158,54 @@ module FunctionExamples = // ================================================ // There are three types of ordered collection: -// * Lists are most basic immutable collection. -// * Arrays are mutable and more efficient when needed. -// * Sequences are lazy and infinite (e.g. an enumerator). +// * Lists are most basic immutable collection. +// * Arrays are mutable and more efficient when needed. +// * Sequences are lazy and infinite (e.g. an enumerator). // // Other collections include immutable maps and sets // plus all the standard .NET collections -module ListExamples = +module ListExamples = - // lists use square brackets + // lists use square brackets let list1 = ["a";"b"] let list2 = "c" :: list1 // :: is prepending let list3 = list1 @ list2 // @ is concat - + // list comprehensions (aka generators) - let squares = [for i in 1..10 do yield i*i] + let squares = [for i in 1..10 do yield i*i] // prime number generator let rec sieve = function | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ] | [] -> [] let primes = sieve [2..50] - printfn "%A" primes - + printfn "%A" primes + // pattern matching for lists - let listMatcher aList = + let listMatcher aList = match aList with - | [] -> printfn "the list is empty" - | [first] -> printfn "the list has one element %A " first - | [first; second] -> printfn "list is %A and %A" first second - | _ -> printfn "the list has more than two elements" + | [] -> printfn "the list is empty" + | [first] -> printfn "the list has one element %A " first + | [first; second] -> printfn "list is %A and %A" first second + | _ -> printfn "the list has more than two elements" listMatcher [1;2;3;4] listMatcher [1;2] listMatcher [1] - listMatcher [] + listMatcher [] // recursion using lists - let rec sum aList = + let rec sum aList = match aList with | [] -> 0 | x::xs -> x + sum xs sum [1..10] - - // ----------------------------------------- - // Standard library functions + + // ----------------------------------------- + // Standard library functions // ----------------------------------------- - + // map let add3 x = x + 3 [1..10] |> List.map add3 @@ -213,68 +213,68 @@ module ListExamples = // filter let even x = x % 2 = 0 [1..10] |> List.filter even - + // many more -- see documentation - -module ArrayExamples = + +module ArrayExamples = // arrays use square brackets with bar let array1 = [| "a";"b" |] let first = array1.[0] // indexed access using dot - + // pattern matching for arrays is same as for lists - let arrayMatcher aList = + let arrayMatcher aList = match aList with - | [| |] -> printfn "the array is empty" - | [| first |] -> printfn "the array has one element %A " first - | [| first; second |] -> printfn "array is %A and %A" first second - | _ -> printfn "the array has more than two elements" + | [| |] -> printfn "the array is empty" + | [| first |] -> printfn "the array has one element %A " first + | [| first; second |] -> printfn "array is %A and %A" first second + | _ -> printfn "the array has more than two elements" arrayMatcher [| 1;2;3;4 |] // Standard library functions just as for List - - [| 1..10 |] + + [| 1..10 |] |> Array.map (fun i -> i+3) |> Array.filter (fun i -> i%2 = 0) |> Array.iter (printfn "value is %i. ") - - -module SequenceExamples = + + +module SequenceExamples = // sequences use curly braces let seq1 = seq { yield "a"; yield "b" } - - // sequences can use yield and + + // sequences can use yield and // can contain subsequences let strange = seq { // "yield! adds one element yield 1; yield 2; - + // "yield!" adds a whole subsequence - yield! [5..10] + yield! [5..10] yield! seq { - for i in 1..10 do + for i in 1..10 do if i%2 = 0 then yield i }} - // test - strange |> Seq.toList - + // test + strange |> Seq.toList + // Sequences can be created using "unfold" // Here's the fibonacci series let fib = Seq.unfold (fun (fst,snd) -> Some(fst + snd, (snd, fst + snd))) (0,1) - // test + // test let fib10 = fib |> Seq.take 10 |> Seq.toList - printf "first 10 fibs are %A" fib10 - - + printf "first 10 fibs are %A" fib10 + + // ================================================ -// Data Types +// Data Types // ================================================ -module DataTypeExamples = +module DataTypeExamples = // All data is immutable by default @@ -282,33 +282,33 @@ module DataTypeExamples = // -- Use a comma to create a tuple let twoTuple = 1,2 let threeTuple = "a",2,true - + // Pattern match to unpack let x,y = twoTuple //sets x=1 y=2 - // ------------------------------------ - // Record types have named fields - // ------------------------------------ + // ------------------------------------ + // Record types have named fields + // ------------------------------------ // Use "type" with curly braces to define a record type type Person = {First:string; Last:string} - - // Use "let" with curly braces to create a record + + // Use "let" with curly braces to create a record let person1 = {First="John"; Last="Doe"} // Pattern match to unpack let {First=first} = person1 //sets first="john" - // ------------------------------------ + // ------------------------------------ // Union types (aka variants) have a set of choices // Only case can be valid at a time. - // ------------------------------------ + // ------------------------------------ // Use "type" with bar/pipe to define a union type - type Temp = + type Temp = | DegreesC of float | DegreesF of float - + // Use one of the cases to create one let temp1 = DegreesF 98.6 let temp2 = DegreesC 37.0 @@ -317,29 +317,29 @@ module DataTypeExamples = let printTemp = function | DegreesC t -> printfn "%f degC" t | DegreesF t -> printfn "%f degF" t - - printTemp temp1 + + printTemp temp1 printTemp temp2 - // ------------------------------------ + // ------------------------------------ // Recursive types - // ------------------------------------ + // ------------------------------------ - // Types can be combined recursively in complex ways + // Types can be combined recursively in complex ways // without having to create subclasses - type Employee = + type Employee = | Worker of Person | Manager of Employee list let jdoe = {First="John";Last="Doe"} let worker = Worker jdoe - - // ------------------------------------ + + // ------------------------------------ // Modelling with types - // ------------------------------------ - + // ------------------------------------ + // Union types are great for modelling state without using flags - type EmailAddress = + type EmailAddress = | ValidEmailAddress of string | InvalidEmailAddress of string @@ -350,40 +350,40 @@ module DataTypeExamples = // The combination of union types and record types together // provide a great foundation for domain driven design. - // You can create hundreds of little types that accurately + // You can create hundreds of little types that accurately // reflect the domain. type CartItem = { ProductCode: string; Qty: int } type Payment = Payment of float type ActiveCartData = { UnpaidItems: CartItem list } type PaidCartData = { PaidItems: CartItem list; Payment: Payment} - - type ShoppingCart = + + type ShoppingCart = | EmptyCart // no data | ActiveCart of ActiveCartData - | PaidCart of PaidCartData + | PaidCart of PaidCartData - // ------------------------------------ + // ------------------------------------ // Built in behavior for types - // ------------------------------------ + // ------------------------------------ // Core types have useful "out-of-the-box" behavior, no coding needed. // * Immutability // * Pretty printing when debugging // * Equality and comparison // * Serialization - + // Pretty printing using %A - printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A" + printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A" twoTuple person1 temp1 worker // Equality and comparison built in. // Here's an example with cards. type Suit = Club | Diamond | Spade | Heart - type Rank = Two | Three | Four | Five | Six | Seven | Eight - | Nine | Ten | Jack | Queen | King | Ace + type Rank = Two | Three | Four | Five | Six | Seven | Eight + | Nine | Ten | Jack | Queen | King | Ace - let hand = [ Club,Ace; Heart,Three; Heart,Ace; + let hand = [ Club,Ace; Heart,Three; Heart,Ace; Spade,Jack; Diamond,Two; Diamond,Ace ] // sorting @@ -391,27 +391,27 @@ module DataTypeExamples = List.max hand |> printfn "high card is %A" List.min hand |> printfn "low card is %A" - + // ================================================ // Active patterns // ================================================ -module ActivePatternExamples = +module ActivePatternExamples = - // F# has a special type of pattern matching called "active patterns" - // where the pattern can be parsed or detected dynamically. + // F# has a special type of pattern matching called "active patterns" + // where the pattern can be parsed or detected dynamically. // "banana clips" are the syntax for active patterns - + // for example, define an "active" pattern to match character types... - let (|Digit|Letter|Whitespace|Other|) ch = + let (|Digit|Letter|Whitespace|Other|) ch = if System.Char.IsDigit(ch) then Digit else if System.Char.IsLetter(ch) then Letter else if System.Char.IsWhiteSpace(ch) then Whitespace - else Other + else Other // ... and then use it to make parsing logic much clearer - let printChar ch = + let printChar ch = match ch with | Digit -> printfn "%c is a Digit" ch | Letter -> printfn "%c is a Letter" ch @@ -424,52 +424,52 @@ module ActivePatternExamples = // ----------------------------------- // FizzBuzz using active patterns // ----------------------------------- - + // You can create partial matching patterns as well // Just use undercore in the defintion, and return Some if matched. let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None // the main function - let fizzBuzz i = + let fizzBuzz i = match i with - | MultOf3 & MultOf5 -> printf "FizzBuzz, " - | MultOf3 -> printf "Fizz, " - | MultOf5 -> printf "Buzz, " + | MultOf3 & MultOf5 -> printf "FizzBuzz, " + | MultOf3 -> printf "Fizz, " + | MultOf5 -> printf "Buzz, " | _ -> printf "%i, " i - + // test - [1..20] |> List.iter fizzBuzz - + [1..20] |> List.iter fizzBuzz + // ================================================ -// Conciseness +// Conciseness // ================================================ -module AlgorithmExamples = +module AlgorithmExamples = - // F# has a high signal/noise ratio, so code reads + // F# has a high signal/noise ratio, so code reads // almost like the actual algorithm // ------ Example: define sumOfSquares function ------ - let sumOfSquares n = + let sumOfSquares n = [1..n] // 1) take all the numbers from 1 to n |> List.map square // 2) square each one |> List.sum // 3) sum the results - // test - sumOfSquares 100 |> printfn "Sum of squares = %A" - - // ------ Example: define a sort function ------ + // test + sumOfSquares 100 |> printfn "Sum of squares = %A" + + // ------ Example: define a sort function ------ let rec sort list = match list with - // If the list is empty - | [] -> + // If the list is empty + | [] -> [] // return an empty list - // If the list is not empty - | firstElem::otherElements -> // take the first element - let smallerElements = // extract the smaller elements + // If the list is not empty + | firstElem::otherElements -> // take the first element + let smallerElements = // extract the smaller elements otherElements // from the remaining ones - |> List.filter (fun e -> e < firstElem) + |> List.filter (fun e -> e < firstElem) |> sort // and sort them let largerElements = // extract the larger ones otherElements // from the remaining ones @@ -479,13 +479,13 @@ module AlgorithmExamples = List.concat [smallerElements; [firstElem]; largerElements] // test - sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A" + sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A" // ================================================ // Asynchronous Code // ================================================ -module AsyncExample = +module AsyncExample = // F# has built-in features to help with async code // without encountering the "pyramid of doom" @@ -495,23 +495,23 @@ module AsyncExample = open System.Net open System open System.IO - open Microsoft.FSharp.Control.CommonExtensions + open Microsoft.FSharp.Control.CommonExtensions // Fetch the contents of a URL asynchronously - let fetchUrlAsync url = - async { // "async" keyword and curly braces + let fetchUrlAsync url = + async { // "async" keyword and curly braces // creates an "async" object - let req = WebRequest.Create(Uri(url)) - use! resp = req.AsyncGetResponse() + let req = WebRequest.Create(Uri(url)) + use! resp = req.AsyncGetResponse() // use! is async assignment - use stream = resp.GetResponseStream() + use stream = resp.GetResponseStream() // "use" triggers automatic close() // on resource at end of scope - use reader = new IO.StreamReader(stream) - let html = reader.ReadToEnd() - printfn "finished downloading %s" url + use reader = new IO.StreamReader(stream) + let html = reader.ReadToEnd() + printfn "finished downloading %s" url } - + // a list of sites to fetch let sites = ["http://www.bing.com"; "http://www.google.com"; @@ -520,7 +520,7 @@ module AsyncExample = "http://www.yahoo.com"] // do it - sites + sites |> List.map fetchUrlAsync // make a list of async tasks |> Async.Parallel // set up the tasks to run in parallel |> Async.RunSynchronously // start them off @@ -529,58 +529,58 @@ module AsyncExample = // .NET compatability // ================================================ -module NetCompatibilityExamples = +module NetCompatibilityExamples = // F# can do almost everything C# can do, and it integrates // seamlessly with .NET or Mono libraries. // ------- work with existing library functions ------- - + let (i1success,i1) = System.Int32.TryParse("123"); if i1success then printfn "parsed as %i" i1 else printfn "parse failed" // ------- Implement interfaces on the fly! ------- - + // create a new object that implements IDisposable - let makeResource name = - { new System.IDisposable + let makeResource name = + { new System.IDisposable with member this.Dispose() = printfn "%s disposed" name } - let useAndDisposeResources = + let useAndDisposeResources = use r1 = makeResource "first resource" - printfn "using first resource" + printfn "using first resource" for i in [1..3] do let resourceName = sprintf "\tinner resource %d" i - use temp = makeResource resourceName - printfn "\tdo something with %s" resourceName + use temp = makeResource resourceName + printfn "\tdo something with %s" resourceName use r2 = makeResource "second resource" - printfn "using second resource" - printfn "done." + printfn "using second resource" + printfn "done." // ------- Object oriented code ------- - + // F# is also a fully fledged OO language. // It supports classes, inheritance, virtual methods, etc. // interface with generic type - type IEnumerator<'a> = + type IEnumerator<'a> = abstract member Current : 'a - abstract MoveNext : unit -> bool + abstract MoveNext : unit -> bool // abstract base class with virtual methods [<AbstractClass>] - type Shape() = + type Shape() = //readonly properties abstract member Width : int with get abstract member Height : int with get //non-virtual method member this.BoundingArea = this.Height * this.Width //virtual method with base implementation - abstract member Print : unit -> unit + abstract member Print : unit -> unit default this.Print () = printfn "I'm a shape" - // concrete class that inherits from base class and overrides - type Rectangle(x:int, y:int) = + // concrete class that inherits from base class and overrides + type Rectangle(x:int, y:int) = inherit Shape() override this.Width = x override this.Height = y @@ -590,20 +590,20 @@ module NetCompatibilityExamples = let r = Rectangle(2,3) printfn "The width is %i" r.Width printfn "The area is %i" r.BoundingArea - r.Print() + r.Print() // ------- extension methods ------- - + //Just as in C#, F# can extend existing classes with extension methods. type System.String with member this.StartsWithA = this.StartsWith "A" //test let s = "Alice" - printfn "'%s' starts with an 'A' = %A" s s.StartsWithA - + printfn "'%s' starts with an 'A' = %A" s s.StartsWithA + // ------- events ------- - + type MyButton() = let clickEvent = new Event<_>() @@ -615,11 +615,11 @@ module NetCompatibilityExamples = // test let myButton = new MyButton() - myButton.OnClick.Add(fun (sender, arg) -> + myButton.OnClick.Add(fun (sender, arg) -> printfn "Click event with arg=%O" arg) myButton.TestEvent("Hello World!") - + ``` ## More Information diff --git a/git.html.markdown b/git.html.markdown index 00f38d60..b1347309 100644 --- a/git.html.markdown +++ b/git.html.markdown @@ -2,22 +2,23 @@ category: tool tool: git contributors: - - ["Jake Prather", "http:#github.com/JakeHP"] + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Leo Rudberg" , "http://github.com/LOZORD"] + - ["Betsy Lorton" , "http://github.com/schbetsy"] filename: LearnGit.txt - --- -Git is a distributed version control and source code management system. +Git is a distributed version control and source code management system. -It does this through a series of snapshots of your project, and it works -with those snapshots to provide you with functionality to version and +It does this through a series of snapshots of your project, and it works +with those snapshots to provide you with functionality to version and manage your source code. ## Versioning Concepts ### What is version control? -Version control is a system that records changes to a file, or set of files, over time. +Version control is a system that records changes to a file(s), over time. ### Centralized Versioning VS Distributed Versioning @@ -41,8 +42,9 @@ Version control is a system that records changes to a file, or set of files, ove ### Repository -A set of files, directories, historical records, commits, and heads. Imagine it as a source code datastructure, -with the attribute that each source code "element" gives you access to its revision history, among other things. +A set of files, directories, historical records, commits, and heads. Imagine it +as a source code data structure, with the attribute that each source code +"element" gives you access to its revision history, among other things. A git repository is comprised of the .git directory & working tree. @@ -53,31 +55,37 @@ The .git directory contains all the configurations, logs, branches, HEAD, and mo ### Working Tree (component of repository) -This is basically the directories and files in your repository. It is often referred to -as your working directory. +This is basically the directories and files in your repository. It is often +referred to as your working directory. ### Index (component of .git dir) The Index is the staging area in git. It's basically a layer that separates your working tree -from the Git repository. This gives developers more power over what gets sent to the Git -repository. +from the Git repository. This gives developers more power over what gets sent +to the Git repository. ### Commit -A git commit is a snapshot of a set of changes, or manipulations to your Working Tree. -For example, if you added 5 files, and removed 2 others, these changes will be contained -in a commit (or snapshot). This commit can then be pushed to other repositories, or not! +A git commit is a snapshot of a set of changes, or manipulations to your Working +Tree. For example, if you added 5 files, and removed 2 others, these changes +will be contained in a commit (or snapshot). This commit can then be pushed to +other repositories, or not! ### Branch -A branch is essentially a pointer that points to the last commit you made. As you commit, -this pointer will automatically update and point to the latest commit. +A branch is essentially a pointer to the last commit you made. As you go on +committing, this pointer will automatically update to point the latest commit. ### HEAD and head (component of .git dir) HEAD is a pointer that points to the current branch. A repository only has 1 *active* HEAD. head is a pointer that points to any commit. A repository can have any number of heads. +### Stages of Git +* Modified - Changes have been made to a file but file has not been committed to Git Database yet +* Staged - Marks a modified file to go into your next commit snapshot +* Committed - Files have been committed to the Git Database + ### Conceptual Resources * [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/) @@ -89,7 +97,7 @@ head is a pointer that points to any commit. A repository can have any number of ### init -Create an empty Git repository. The Git repository's settings, stored information, +Create an empty Git repository. The Git repository's settings, stored information, and more is stored in a directory (a folder) named ".git". ```bash @@ -98,15 +106,12 @@ $ git init ### config -To configure settings. Whether it be for the repository, the system itself, or global -configurations. +To configure settings. Whether it be for the repository, the system itself, +or global configurations ( global config file is `~/.gitconfig` ). ```bash # Print & Set Some Basic Config Variables (Global) -$ git config --global user.email -$ git config --global user.name - $ git config --global user.email "MyEmail@Zoho.com" $ git config --global user.name "My Name" ``` @@ -130,12 +135,26 @@ $ git help -a $ git help add $ git help commit $ git help init +# or git <command_here> --help +$ git add --help +$ git commit --help +$ git init --help ``` +### ignore files + +To intentionally untrack file(s) & folder(s) from git. Typically meant for +private & temp files which would otherwise be shared in the repository. +```bash +$ echo "temp/" >> .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 @@ -148,8 +167,8 @@ $ git help status ### add -To add files to the current working tree/directory/repo. If you do not `git add` new files to the -working tree/directory, they will not be included in commits! +To add files to the staging area/index. If you do not `git add` new files to the +staging area/index, they will not be included in commits! ```bash # add a file in your current working directory @@ -162,6 +181,9 @@ $ 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. + ### branch Manage your branches. You can view, edit, create, delete branches using this command. @@ -193,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 <name>; git checkout <name>" +# Create a new branch & switch to it +# equivalent to "git branch <name>; git checkout <name>" $ git checkout -b newBranch ``` @@ -206,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 @@ -216,6 +243,12 @@ the changes made and a message created by the user. ```bash # commit with a message $ 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 @@ -253,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 @@ -267,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 @@ -288,7 +321,7 @@ $ git merge --no-ff branchName ### mv -Rename or move a file +Rename or move a file ```bash # Renaming a file @@ -310,7 +343,12 @@ Pulls from a repository and merges it with another branch. # Update your local repo, by merging in new changes # from the remote "origin" and "master" branch. # git pull <remote> <branch> +# git pull => implicitly defaults to => git pull origin master $ git pull origin master + +# Merge in changes from remote branch and rebase +# branch commits onto your local repo, like: "git pull <remote> <branch>, git rebase <branch>" +$ git pull origin master --rebase ``` ### push @@ -318,14 +356,81 @@ $ git pull origin master 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 <remote> <branch> # git push => implicitly defaults to => git push origin master $ 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 +``` + +### 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. + +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") +``` + +Now you can pull! + +```bash +git pull +``` +`...changes apply...` + +Now check that everything is OK + +```bash +$ git status +# On branch master +nothing to commit, working directory clean +``` + +You can see what "hunks" you've stashed so far using `git stash list`. +Since the "hunks" are stored in a Last-In-First-Out stack, our most recent change will be at top. + +```bash +$ git stash list +stash@{0}: WIP on master: 049d078 added the index file +stash@{1}: WIP on master: c264051 Revert "added file_size" +stash@{2}: WIP on master: 21d80a5 added number to log ``` -### rebase (caution) +Now let's apply our dirty changes back by popping them off the stack. + +```bash +$ git stash pop +# On branch master +# Changes not staged for commit: +# (use "git add <file>..." to update what will be committed) +# +# modified: index.html +# modified: lib/simplegit.rb +# +``` + +`git stash apply` does the same thing + +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) 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*. @@ -377,6 +482,8 @@ $ git rm /pather/to/the/file/HelloWorld.c * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) +* [Udemy Git Tutorial: A Comprehensive Guide](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/) + * [git-scm - Video Tutorials](http://git-scm.com/videos) * [git-scm - Documentation](http://git-scm.com/docs) @@ -386,3 +493,7 @@ $ git rm /pather/to/the/file/HelloWorld.c * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) * [GitGuys](http://www.gitguys.com/) + +* [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html) + +* [Pro Git](http://www.git-scm.com/book/en/v2) diff --git a/go.html.markdown b/go.html.markdown new file mode 100644 index 00000000..34b855e3 --- /dev/null +++ b/go.html.markdown @@ -0,0 +1,422 @@ +--- +name: Go +category: language +language: Go +filename: learngo.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] +--- + +Go was created out of the need to get work done. It's not the latest trend +in computer science, but it is the newest fastest way to solve real-world +problems. + +It has familiar concepts of imperative languages with static typing. +It's fast to compile and fast to execute, it adds easy-to-understand +concurrency to leverage today's multi-core CPUs, and has features to +help with large-scale programming. + +Go comes with a great standard library and an enthusiastic community. + +```go +// Single line comment +/* Multi- + line comment */ + +// A package clause starts every source file. +// Main is a special name declaring an executable rather than a library. +package main + +// Import declaration declares library packages referenced in this file. +import ( + "fmt" // A package in the Go standard library. + "io/ioutil" // Implements some I/O utility functions. + m "math" // Math library with local alias m. + "net/http" // Yes, a web server! + "strconv" // String conversions. +) + +// A function definition. Main is special. It is the entry point for the +// executable program. Love it or hate it, Go uses brace brackets. +func main() { + // Println outputs a line to stdout. + // Qualify it with the package name, fmt. + fmt.Println("Hello world!") + + // Call another function within this package. + beyondHello() +} + +// Functions have parameters in parentheses. +// If there are no parameters, empty parentheses are still required. +func beyondHello() { + var x int // Variable declaration. Variables must be declared before use. + x = 3 // Variable assignment. + // "Short" declarations use := to infer the type, declare, and assign. + y := 4 + sum, prod := learnMultiple(x, y) // Function returns two values. + fmt.Println("sum:", sum, "prod:", prod) // Simple output. + learnTypes() // < y minutes, learn more! +} + +/* <- multiline comment +Functions can have parameters and (multiple!) return values. +Here `x`, `y` are the arguments and `sum`, `prod` is the signature (what's returned). +Note that `x` and `sum` receive the type `int`. +*/ +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Return two values. +} + +// Some built-in types and literals. +func learnTypes() { + // Short declaration usually gives you what you want. + str := "Learn Go!" // string type. + + s2 := `A "raw" string literal +can include line breaks.` // Same string type. + + // Non-ASCII literal. Go source is UTF-8. + g := 'Σ' // rune type, an alias for int32, holds a unicode code point. + + f := 3.14195 // float64, an IEEE-754 64-bit floating point number. + c := 3 + 4i // complex128, represented internally with two float64's. + + // var syntax with initializers. + var u uint = 7 // Unsigned, but implementation dependent size as with int. + var pi float32 = 22. / 7 + + // Conversion syntax with a short declaration. + n := byte('\n') // byte is an alias for uint8. + + // Arrays have size fixed at compile time. + var a4 [4]int // An array of 4 ints, initialized to all 0. + a3 := [...]int{3, 1, 5} // An array initialized with a fixed size of three + // elements, with values 3, 1, and 5. + + // Slices have dynamic size. Arrays and slices each have advantages + // but use cases for slices are much more common. + s3 := []int{4, 5, 9} // Compare to a3. No ellipsis here. + s4 := make([]int, 4) // Allocates slice of 4 ints, initialized to all 0. + var d2 [][]float64 // Declaration only, nothing allocated here. + bs := []byte("a slice") // Type conversion syntax. + + // Because they are dynamic, slices can be appended to on-demand. + // To append elements to a slice, built-in append() function is used. + // First argument is a slice to which we are appending. Commonly, + // the array variable is updated in place, as in example below. + s := []int{1, 2, 3} // Result is a slice of length 3. + s = append(s, 4, 5, 6) // Added 3 elements. Slice now has length of 6. + fmt.Println(s) // Updated slice is now [1 2 3 4 5 6] + // To append another slice, instead of list of atomic elements we can + // pass a reference to a slice or a slice literal like this, with a + // trailing elipsis, meaning take a slice and unpack its elements, + // appending them to slice s. + s = append(s, []int{7, 8, 9}...) // Second argument is a slice literal. + fmt.Println(s) // Updated slice is now [1 2 3 4 5 6 7 8 9] + + p, q := learnMemory() // Declares p, q to be type pointer to int. + fmt.Println(*p, *q) // * follows a pointer. This prints two ints. + + // Maps are a dynamically growable associative array type, like the + // hash or dictionary types of some other languages. + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + // Unused variables are an error in Go. + // The underbar lets you "use" a variable but discard its value. + _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs + // Output of course counts as using a variable. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // Back in the flow. +} + +// It is possible, unlike in many other languages for functions in go +// to have named return values. +// Assigning a name to the type being returned in the function declaration line +// allows us to easily return from multiple points in a function as well as to +// only use the return keyword, without anything further. +func learnNamedReturns(x, y int) (z int) { + z = x * y + return // z is implicit here, because we named it earlier. +} + +// Go is fully garbage collected. It has pointers but no pointer arithmetic. +// You can make a mistake with a nil pointer, but not by incrementing a pointer. +func learnMemory() (p, q *int) { + // Named return values p and q have type pointer to int. + p = new(int) // Built-in function new allocates memory. + // The allocated int is initialized to 0, p is no longer nil. + s := make([]int, 20) // Allocate 20 ints as a single block of memory. + s[3] = 7 // Assign one of them. + r := -2 // Declare another local variable. + return &s[3], &r // & takes the address of an object. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // If statements require brace brackets, and do not require parens. + if true { + fmt.Println("told ya") + } + // Formatting is standardized by the command line command "go fmt." + if false { + // Pout. + } else { + // Gloat. + } + // Use switch in preference to chained if statements. + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Cases don't "fall through". + /* + There is a `fallthrough` keyword however, see: + https://github.com/golang/go/wiki/Switch#fall-through + */ + case 43: + // Unreached. + default: + // Default case is optional. + } + // Like if, for doesn't use parens either. + // Variables declared in for and if are local to their scope. + for x := 0; x < 3; x++ { // ++ is a statement. + fmt.Println("iteration", x) + } + // x == 42 here. + + // For is the only loop statement in Go, but it has alternate forms. + for { // Infinite loop. + break // Just kidding. + continue // Unreached. + } + + // You can use range to iterate over an array, a slice, a string, a map, or a channel. + // range returns one (channel) or two values (array, slice, string and map). + for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} { + // for each pair in the map, print key and value + fmt.Printf("key=%s, value=%d\n", key, value) + } + + // As with for, := in an if statement means to declare and assign + // y first, then test y > x. + if y := expensiveComputation(); y > x { + x = y + } + // Function literals are closures. + xBig := func() bool { + return x > 10000 // References x declared above switch statement. + } + fmt.Println("xBig:", xBig()) // true (we last assigned e^10 to x). + x = 1.3e3 // This makes x == 1300 + fmt.Println("xBig:", xBig()) // false now. + + // What's more is function literals may be defined and called inline, + // acting as an argument to function, as long as: + // a) function literal is called immediately (), + // b) result type matches expected type of argument. + fmt.Println("Add + double two numbers: ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Called with args 10 and 2 + // => Add + double two numbers: 24 + + // When you need it, you'll love it. + goto love +love: + + learnFunctionFactory() // func returning func is fun(3)(3) + learnDefer() // A quick detour to an important keyword. + learnInterfaces() // Good stuff coming up! +} + +func learnFunctionFactory() { + // Next two are equivalent, with second being more practical + fmt.Println(sentenceFactory("summer")("A beautiful", "day!")) + + d := sentenceFactory("summer") + fmt.Println(d("A beautiful", "day!")) + fmt.Println(d("A lazy", "afternoon!")) +} + +// Decorators are common in other languages. Same can be done in Go +// with function literals that accept arguments. +func sentenceFactory(mystring string) func(before, after string) string { + return func(before, after string) string { + return fmt.Sprintf("%s %s %s", before, mystring, after) // new string + } +} + +func learnDefer() (ok bool) { + // Deferred statements are executed just before the function returns. + defer fmt.Println("deferred statements execute in reverse (LIFO) order.") + defer fmt.Println("\nThis line is being printed first because") + // Defer is commonly used to close a file, so the function closing the + // file stays close to the function opening the file. + return true +} + +// Define Stringer as an interface type with one method, String. +type Stringer interface { + String() string +} + +// Define pair as a struct with two fields, ints named x and y. +type pair struct { + x, y int +} + +// Define a method on type pair. Pair now implements Stringer. +func (p pair) String() string { // p is called the "receiver" + // Sprintf is another public function in package fmt. + // Dot syntax references fields of p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Brace syntax is a "struct literal". It evaluates to an initialized + // struct. The := syntax declares and initializes p to this struct. + p := pair{3, 4} + fmt.Println(p.String()) // Call String method of p, of type pair. + var i Stringer // Declare i of interface type Stringer. + i = p // Valid because pair implements Stringer + // Call String method of i, of type Stringer. Output same as above. + fmt.Println(i.String()) + + // Functions in the fmt package call the String method to ask an object + // for a printable representation of itself. + fmt.Println(p) // Output same as above. Println calls String method. + fmt.Println(i) // Output same as above. + + learnVariadicParams("great", "learning", "here!") +} + +// Functions can have variadic parameters. +func learnVariadicParams(myStrings ...interface{}) { + // Iterate each value of the variadic. + // The underbar here is ignoring the index argument of the array. + for _, param := range myStrings { + fmt.Println("param:", param) + } + + // Pass variadic value as a variadic parameter. + fmt.Println("params:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" idiom used to tell if something worked or not. + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // ok will be false because 1 is not in the map. + fmt.Println("no one there") + } else { + fmt.Print(x) // x would be the value, if it were in the map. + } + // An error value communicates not just "ok" but more about the problem. + if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value + // prints 'strconv.ParseInt: parsing "non-int": invalid syntax' + fmt.Println(err) + } + // We'll revisit interfaces a little later. Meanwhile, + learnConcurrency() +} + +// c is a channel, a concurrency-safe communication object. +func inc(i int, c chan int) { + c <- i + 1 // <- is the "send" operator when a channel appears on the left. +} + +// We'll use inc to increment some numbers concurrently. +func learnConcurrency() { + // Same make function used earlier to make a slice. Make allocates and + // initializes slices, maps, and channels. + c := make(chan int) + // Start three concurrent goroutines. Numbers will be incremented + // concurrently, perhaps in parallel if the machine is capable and + // properly configured. All three send to the same channel. + go inc(0, c) // go is a statement that starts a new goroutine. + go inc(10, c) + go inc(-805, c) + // Read three results from the channel and print them out. + // There is no telling in what order the results will arrive! + fmt.Println(<-c, <-c, <-c) // channel on right, <- is "receive" operator. + + cs := make(chan string) // Another channel, this one handles strings. + ccs := make(chan chan string) // A channel of string channels. + go func() { c <- 84 }() // Start a new goroutine just to send a value. + go func() { cs <- "wordy" }() // Again, for cs this time. + // Select has syntax like a switch statement but each case involves + // a channel operation. It selects a case at random out of the cases + // that are ready to communicate. + select { + case i := <-c: // The value received can be assigned to a variable, + fmt.Printf("it's a %T", i) + case <-cs: // or the value received can be discarded. + fmt.Println("it's a string") + case <-ccs: // Empty channel, not ready for communication. + fmt.Println("didn't happen.") + } + // At this point a value was taken from either c or cs. One of the two + // goroutines started above has completed, the other will remain blocked. + + learnWebProgramming() // Go does it. You want to do it too. +} + +// A single function from package http starts a web server. +func learnWebProgramming() { + + // First parameter of ListenAndServe is TCP address to listen to. + // Second parameter is an interface, specifically http.Handler. + go func() { + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // don't ignore errors + }() + + requestServer() +} + +// Make pair an http.Handler by implementing its only method, ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Serve data with a method of http.ResponseWriter. + w.Write([]byte("You learned Go in Y minutes!")) +} + +func requestServer() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nWebserver said: `%s`", string(body)) +} +``` + +## Further Reading + +The root of all things Go is the [official Go web site](http://golang.org/). +There you can follow the tutorial, play interactively, and read lots. + +The language definition itself is highly recommended. It's easy to read +and amazingly short (as language definitions go these days.) + +You can play around with the code on [Go playground](https://play.golang.org/p/tnWMjr16Mm). Try to change it and run it from your browser! Note that you can use [https://play.golang.org](https://play.golang.org) as a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) to test things and code in your browser, without even installing Go. + +On the reading list for students of Go is the [source code to the standard +library](http://golang.org/src/pkg/). Comprehensively documented, it +demonstrates the best of readable and understandable Go, Go style, and Go +idioms. Or you can click on a function name in [the +documentation](http://golang.org/pkg/) and the source code comes up! + +Another great resource to learn Go is [Go by example](https://gobyexample.com/). diff --git a/groovy.html.markdown b/groovy.html.markdown new file mode 100644 index 00000000..492c1ba2 --- /dev/null +++ b/groovy.html.markdown @@ -0,0 +1,432 @@ +--- +language: Groovy +filename: learngroovy.groovy +contributors: + - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"] +filename: learngroovy.groovy +--- + +Groovy - A dynamic language for the Java platform [Read more here.](http://www.groovy-lang.org/) + +```groovy + +/* + Set yourself up: + + 1) Install GVM - http://gvmtool.net/ + 2) Install Groovy: gvm install groovy + 3) Start the groovy console by typing: groovyConsole + +*/ + +// Single line comments start with two forward slashes +/* +Multi line comments look like this. +*/ + +// Hello World +println "Hello world!" + +/* + Variables: + + You can assign values to variables for later use +*/ + +def x = 1 +println x + +x = new java.util.Date() +println x + +x = -3.1499392 +println x + +x = false +println x + +x = "Groovy!" +println x + +/* + Collections and maps +*/ + +//Creating an empty list +def technologies = [] + +/*** Adding a elements to the list ***/ + +// As with Java +technologies.add("Grails") + +// Left shift adds, and returns the list +technologies << "Groovy" + +// Add multiple elements +technologies.addAll(["Gradle","Griffon"]) + +/*** Removing elements from the list ***/ + +// As with Java +technologies.remove("Griffon") + +// Subtraction works also +technologies = technologies - 'Grails' + +/*** Iterating Lists ***/ + +// Iterate over elements of a list +technologies.each { println "Technology: $it"} +technologies.eachWithIndex { it, i -> println "$i: $it"} + +/*** Checking List contents ***/ + +//Evaluate if a list contains element(s) (boolean) +contained = technologies.contains( 'Groovy' ) + +// Or +contained = 'Groovy' in technologies + +// Check for multiple contents +technologies.containsAll(['Groovy','Grails']) + +/*** Sorting Lists ***/ + +// Sort a list (mutates original list) +technologies.sort() + +// To sort without mutating original, you can do: +sortedTechnologies = technologies.sort( false ) + +/*** Manipulating Lists ***/e + +//Replace all elements in the list +Collections.replaceAll(technologies, 'Gradle', 'gradle') + +//Shuffle a list +Collections.shuffle(technologies, new Random()) + +//Clear a list +technologies.clear() + +//Creating an empty map +def devMap = [:] + +//Add values +devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] +devMap.put('lastName','Perez') + +//Iterate over elements of a map +devMap.each { println "$it.key: $it.value" } +devMap.eachWithIndex { it, i -> println "$i: $it"} + +//Evaluate if a map contains a key +assert devMap.containsKey('name') + +//Evaluate if a map contains a value +assert devMap.containsValue('Roberto') + +//Get the keys of a map +println devMap.keySet() + +//Get the values of a map +println devMap.values() + +/* + Groovy Beans + + GroovyBeans are JavaBeans but using a much simpler syntax + + When Groovy is compiled to bytecode, the following rules are used. + + * If the name is declared with an access modifier (public, private or + protected) then a field is generated. + + * A name declared with no access modifier generates a private field with + public getter and setter (i.e. a property). + + * If a property is declared final the private field is created final and no + setter is generated. + + * You can declare a property and also declare your own getter or setter. + + * You can declare a property and a field of the same name, the property will + use that field then. + + * If you want a private or protected property you have to provide your own + getter and setter which must be declared private or protected. + + * If you access a property from within the class the property is defined in + at compile time with implicit or explicit this (for example this.foo, or + simply foo), Groovy will access the field directly instead of going though + the getter and setter. + + * If you access a property that does not exist using the explicit or + implicit foo, then Groovy will access the property through the meta class, + which may fail at runtime. + +*/ + +class Foo { + // read only property + final String name = "Roberto" + + // read only property with public getter and protected setter + String language + protected void setLanguage(String language) { this.language = language } + + // dynamically typed property + def lastName +} + +/* + Logical Branching and Looping +*/ + +//Groovy supports the usual if - else syntax +def x = 3 + +if(x==1) { + println "One" +} else if(x==2) { + println "Two" +} else { + println "X greater than Two" +} + +//Groovy also supports the ternary operator: +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 +for (i in 0 .. 30) { + x += i +} + +//Iterate over a list +x = 0 +for( i in [5,3,2,1] ) { + x += i +} + +//Iterate over an array +array = (0..20).toArray() +x = 0 +for (i in array) { + x += i +} + +//Iterate over a map +def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] +x = 0 +for ( e in map ) { + x += e.value +} + +/* + Operators + + Operator Overloading for a list of the common operators that Groovy supports: + http://www.groovy-lang.org/operators.html#Operator-Overloading + + Helpful groovy operators +*/ +//Spread operator: invoke an action on all items of an aggregate object. +def technologies = ['Groovy','Grails','Gradle'] +technologies*.toUpperCase() // = to technologies.collect { it?.toUpperCase() } + +//Safe navigation operator: used to avoid a NullPointerException. +def user = User.get(1) +def username = user?.username + + +/* + Closures + A Groovy Closure is like a "code block" or a method pointer. It is a piece of + code that is defined and then executed at a later point. + + More info at: http://www.groovy-lang.org/closures.html +*/ +//Example: +def clos = { println "Hello World!" } + +println "Executing the Closure:" +clos() + +//Passing parameters to a closure +def sum = { a, b -> println a+b } +sum(2,4) + +//Closures may refer to variables not listed in their parameter list. +def x = 5 +def multiplyBy = { num -> num * x } +println multiplyBy(10) + +// If you have a Closure that takes a single argument, you may omit the +// parameter definition of the Closure +def clos = { print it } +clos( "hi" ) + +/* + Groovy can memorize closure results [1][2][3] +*/ +def cl = {a, b -> + sleep(3000) // simulate some time consuming processing + a + b +} + +mem = cl.memoize() + +def callClosure(a, b) { + def start = System.currentTimeMillis() + mem(a, b) + println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs." +} + +callClosure(1, 2) +callClosure(1, 2) +callClosure(2, 3) +callClosure(2, 3) +callClosure(3, 4) +callClosure(3, 4) +callClosure(1, 2) +callClosure(2, 3) +callClosure(3, 4) + +/* + Expando + + The Expando class is a dynamic bean so we can add properties and we can add + closures as methods to an instance of this class + + http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html +*/ + def user = new Expando(name:"Roberto") + assert 'Roberto' == user.name + + user.lastName = 'Pérez' + assert 'Pérez' == user.lastName + + user.showInfo = { out -> + out << "Name: $name" + out << ", Last name: $lastName" + } + + def sw = new StringWriter() + println user.showInfo(sw) + + +/* + Metaprogramming (MOP) +*/ + +//Using ExpandoMetaClass to add behaviour +String.metaClass.testAdd = { + println "we added this" +} + +String x = "test" +x?.testAdd() + +//Intercepting method calls +class Test implements GroovyInterceptable { + def sum(Integer x, Integer y) { x + y } + + def invokeMethod(String name, args) { + System.out.println "Invoke method $name with args: $args" + } +} + +def test = new Test() +test?.sum(2,3) +test?.multiply(2,3) + +//Groovy supports propertyMissing for dealing with property resolution attempts. +class Foo { + def propertyMissing(String name) { name } +} +def f = new Foo() + +assertEquals "boo", f.boo + +/* + TypeChecked and CompileStatic + Groovy, by nature, is and will always be a dynamic language but it supports + typechecked and compilestatic + + More info: http://www.infoq.com/articles/new-groovy-20 +*/ +//TypeChecked +import groovy.transform.TypeChecked + +void testMethod() {} + +@TypeChecked +void test() { + testMeethod() + + def name = "Roberto" + + println naameee + +} + +//Another example: +import groovy.transform.TypeChecked + +@TypeChecked +Integer test() { + Integer num = "1" + + Integer[] numbers = [1,2,3,4] + + Date date = numbers[1] + + return "Test" + +} + +//CompileStatic example: +import groovy.transform.CompileStatic + +@CompileStatic +int sum(int x, int y) { + x + y +} + +assert sum(2,5) == 7 + + +``` + +## Further resources + +[Groovy documentation](http://www.groovy-lang.org/documentation.html) + +[Groovy web console](http://groovyconsole.appspot.com/) + +Join a [Groovy user group](http://www.groovy-lang.org/usergroups.html) + +## Books + +* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook) + +* [Groovy in Action] (http://manning.com/koenig2/) + +* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do) + +[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 new file mode 100644 index 00000000..b3d19f8e --- /dev/null +++ b/hack.html.markdown @@ -0,0 +1,308 @@ +--- +language: Hack +contributors: + - ["Stephen Holdaway", "https://github.com/stecman"] + - ["David Lima", "https://github.com/davelima"] +filename: learnhack.hh +--- + +Hack is a superset of PHP that runs under a virtual machine called HHVM. Hack +is almost completely interoperable with existing PHP code and adds a bunch of +useful features from statically typed languages. + + +Only Hack-specific features are covered here. Details about PHP's syntax are +available in the [PHP article](http://learnxinyminutes.com/docs/php/) on this site. + +```php +<?hh + +// Hack syntax is only enabled for files starting with an <?hh marker +// <?hh markers cannot be interspersed with HTML the way <?php can be. +// Using the marker "<?hh //strict" puts the type checker in strict mode. + + +// Scalar parameter type hints +function repeat(string $word, int $count) +{ + $word = trim($word); + return str_repeat($word . ' ', $count); +} + +// Type hints for return values +function add(...$numbers) : int +{ + return array_sum($numbers); +} + +// Functions that return nothing are hinted as "void" +function truncate(resource $handle) : void +{ + // ... +} + +// Type hints must explicitly allow being nullable +function identity(?string $stringOrNull) : ?string +{ + return $stringOrNull; +} + +// Type hints can be specified on class properties +class TypeHintedProperties +{ + public ?string $name; + + protected int $id; + + private float $score = 100.0; + + // Hack's type checker enforces that typed properties either have a + // default value or are set in the constructor. + public function __construct(int $id) + { + $this->id = $id; + } +} + + +// Concise anonymous functions (lambdas) +$multiplier = 5; +array_map($y ==> $y * $multiplier, [1, 2, 3]); + + +// Generics +class Box<T> +{ + protected T $data; + + public function __construct(T $data) { + $this->data = $data; + } + + public function getData(): T { + return $this->data; + } +} + +function openBox(Box<int> $box) : int +{ + return $box->getData(); +} + + +// Shapes +// +// Hack adds the concept of shapes for defining struct-like arrays with a +// guaranteed, type-checked set of keys +type Point2D = shape('x' => int, 'y' => int); + +function distance(Point2D $a, Point2D $b) : float +{ + return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2)); +} + +distance( + shape('x' => -1, 'y' => 5), + shape('x' => 2, 'y' => 50) +); + + +// Type aliasing +// +// Hack adds a bunch of type aliasing features for making complex types readable +newtype VectorArray = array<int, Vector<int>>; + +// A tuple containing two integers +newtype Point = (int, int); + +function addPoints(Point $p1, Point $p2) : Point +{ + return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]); +} + +addPoints( + tuple(1, 2), + tuple(5, 6) +); + + +// First-class enums +enum RoadType : int +{ + Road = 0; + Street = 1; + Avenue = 2; + Boulevard = 3; +} + +function getRoadType() : RoadType +{ + return RoadType::Avenue; +} + + +// Constructor argument promotion +// +// To avoid boilerplate property and constructor definitions that only set +// properties, Hack adds a concise syntax for defining properties and a +// constructor at the same time. +class ArgumentPromotion +{ + public function __construct(public string $name, + protected int $age, + private bool $isAwesome) {} +} + +class WithoutArgumentPromotion +{ + public string $name; + + protected int $age; + + private bool $isAwesome; + + public function __construct(string $name, int $age, bool $isAwesome) + { + $this->name = $name; + $this->age = $age; + $this->isAwesome = $isAwesome; + } +} + + +// Co-operative multi-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<void> +{ + for ($i = $start; $i <= $end; $i++) { + echo "$i "; + + // Give other tasks a chance to do something + await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0); + } +} + +// This prints "1 4 7 2 5 8 3 6 9" +AwaitAllWaitHandle::fromArray([ + cooperativePrint(1, 3), + cooperativePrint(4, 6), + cooperativePrint(7, 9) +])->getWaitHandle()->join(); + + +// Attributes +// +// Attributes are a form of metadata for functions. Hack provides some +// special built-in attributes that introduce useful behaviour. + +// The __Memoize special attribute causes the result of a function to be cached +<<__Memoize>> +function doExpensiveTask() : ?string +{ + return file_get_contents('http://example.com'); +} + +// The function's body is only executed once here: +doExpensiveTask(); +doExpensiveTask(); + + +// The __ConsistentConstruct special attribute signals the Hack type checker to +// ensure that the signature of __construct is the same for all subclasses. +<<__ConsistentConstruct>> +class ConsistentFoo +{ + public function __construct(int $x, float $y) + { + // ... + } + + public function someMethod() + { + // ... + } +} + +class ConsistentBar extends ConsistentFoo +{ + public function __construct(int $x, float $y) + { + // Hack's type checker enforces that parent constructors are called + parent::__construct($x, $y); + + // ... + } + + // The __Override annotation is an optional signal for the Hack type + // checker to enforce that this method is overriding a method in a parent + // or trait. If not, this will error. + <<__Override>> + public function someMethod() + { + // ... + } +} + +class InvalidFooSubclass extends ConsistentFoo +{ + // Not matching the parent constructor will cause a type checker error: + // + // "This object is of type ConsistentBaz. It is incompatible with this object + // of type ConsistentFoo because some of their methods are incompatible" + // + public function __construct(float $x) + { + // ... + } + + // Using the __Override annotation on a non-overriden method will cause a + // type checker error: + // + // "InvalidFooSubclass::otherMethod() is marked as override; no non-private + // parent definition found or overridden parent is defined in non-<?hh code" + // + <<__Override>> + public function otherMethod() + { + // ... + } +} + + +// Traits can implement interfaces (standard PHP does not support this) +interface KittenInterface +{ + public function play() : void; +} + +trait CatTrait implements KittenInterface +{ + public function play() : void + { + // ... + } +} + +class Samuel +{ + use CatTrait; +} + + +$cat = new Samuel(); +$cat instanceof KittenInterface === true; // True + +``` + +## More Information + +Visit the [Hack language reference](http://docs.hhvm.com/manual/en/hacklangref.php) +for detailed explainations of the features Hack adds to PHP, or the [official Hack website](http://hacklang.org/) +for more general information. + +Visit the [official HHVM website](http://hhvm.com/) for HHVM installation instructions. + +Visit [Hack's unsupported PHP features article](http://docs.hhvm.com/manual/en/hack.unsupported.php) +for details on the backwards incompatibility between Hack and PHP. diff --git a/haml.html.markdown b/haml.html.markdown new file mode 100644 index 00000000..847714e6 --- /dev/null +++ b/haml.html.markdown @@ -0,0 +1,155 @@ +--- +language: haml +filename: learnhaml.haml +contributors: + - ["Simon Neveu", "https://github.com/sneveu"] +--- + +Haml is a markup language predominantly used with Ruby that cleanly and simply describes the HTML of any web document without the use of inline code. It is a popular alternative to using Rails templating language (.erb) and allows you to embed Ruby code into your markup. + +It aims to reduce repetition in your markup by closing tags for you based on the structure of the indents in your code. The result is markup that is well-structured, DRY, logical, and easier to read. + +You can also use Haml on a project independent of Ruby, by installing the Haml gem on your machine and using the command line to convert it to html. + +$ haml input_file.haml output_file.html + + +```haml +/ ------------------------------------------- +/ Indenting +/ ------------------------------------------- + +/ + Because of the importance indentation has on how your code is rendered, the + indents should be consistent throughout the document. Any differences in + indentation will throw an error. It's common-practice to use two spaces, + but it's really up to you, as long as they're constant. + + +/ ------------------------------------------- +/ Comments +/ ------------------------------------------- + +/ This is what a comment looks like in Haml. + +/ + To write a multi line comment, indent your commented code to be + wrapped by the forward slash + +-# This is a silent comment, which means it wont be rendered into the doc at all + + +/ ------------------------------------------- +/ Html elements +/ ------------------------------------------- + +/ To write your tags, use the percent sign followed by the name of the tag +%body + %header + %nav + +/ Notice no closing tags. The above code would output + <body> + <header> + <nav></nav> + </header> + </body> + +/ The div tag is the default element, so they can be written simply like this +.foo + +/ To add content to a tag, add the text directly after the declaration +%h1 Headline copy + +/ To write multiline content, nest it instead +%p + This is a lot of content that we could probably split onto two + separate lines. + +/ + You can escape html by using the ampersand and equals sign ( &= ). This + converts html-sensitive characters (&, /, :) into their html encoded + equivalents. For example + +%p + &= "Yes & yes" + +/ would output 'Yes & yes' + +/ You can unescape html by using the bang and equals sign ( != ) +%p + != "This is how you write a paragraph tag <p></p>" + +/ which would output 'This is how you write a paragraph tag <p></p>' + +/ CSS classes can be added to your tags either by chaining .classnames to the tag +%div.foo.bar + +/ or as part of a Ruby hash +%div{:class => 'foo bar'} + +/ Attributes for any tag can be added in the hash +%a{:href => '#', :class => 'bar', :title => 'Bar'} + +/ For boolean attributes assign the value 'true' +%input{:selected => true} + +/ To write data-attributes, use the :data key with its value as another hash +%div{:data => {:attribute => 'foo'}} + + +/ ------------------------------------------- +/ Inserting Ruby +/ ------------------------------------------- + +/ + To output a Ruby value as the contents of a tag, use an equals sign followed + by the Ruby code + +%h1= book.name + +%p + = book.author + = book.publisher + + +/ To run some Ruby code without rendering it to the html, use a hyphen instead +- books = ['book 1', 'book 2', 'book 3'] + +/ Allowing you to do all sorts of awesome, like Ruby blocks +- books.shuffle.each_with_index do |book, index| + %h1= book + + if book do + %p This is a book + +/ + Again, no need to add the closing tags to the block, even for the Ruby. + Indentation will take care of that for you. + + +/ ------------------------------------------- +/ Inline Ruby / Ruby interpolation +/ ------------------------------------------- + +/ Include a Ruby variable in a line of plain text using #{} +%p Your highest scoring game is #{best_game} + + +/ ------------------------------------------- +/ Filters +/ ------------------------------------------- + +/ + Use the colon to define Haml filters, one example of a filter you can + use is :javascript, which can be used for writing inline js + +:javascript + console.log('This is inline <script>'); + +``` + +## Additional resources + +- [What is HAML?](http://haml.info/) - A good introduction that does a much better job of explaining the benefits of using HAML. +- [Official Docs](http://haml.info/docs/yardoc/file.REFERENCE.html) - If you'd like to go a little deeper. diff --git a/haskell.html.markdown b/haskell.html.markdown index be7d8669..369b1b20 100644 --- a/haskell.html.markdown +++ b/haskell.html.markdown @@ -1,17 +1,17 @@ --- -language: haskell +language: Haskell contributors: - ["Adit Bhargava", "http://adit.io"] --- -Haskell was designed as a practical, purely functional programming language. It's famous for -its monads and its type system, but I keep coming back to it because of its elegance. Haskell -makes coding a real joy for me. +Haskell was designed as a practical, purely functional programming +language. It's famous for its monads and its type system, but I keep coming back +to it because of its elegance. Haskell makes coding a real joy for me. ```haskell -- Single line comments start with two dashes. {- Multiline comments can be enclosed -en a block like this. +in a block like this. -} ---------------------------------------------------- @@ -59,6 +59,7 @@ not False -- True "Hello " ++ "world!" -- "Hello world!" -- A string is a list of characters +['H', 'e', 'l', 'l', 'o'] -- "Hello" "This is a string" !! 0 -- 'T' @@ -67,10 +68,21 @@ not False -- True ---------------------------------------------------- -- Every element in a list must have the same type. --- Two lists that are the same +-- These two lists are the same: [1, 2, 3, 4, 5] [1..5] +-- Ranges are versatile. +['A'..'F'] -- "ABCDEF" + +-- You can create a step in a range. +[0,2..10] -- [0, 2, 4, 6, 8, 10] +[5..1] -- This doesn't work because Haskell defaults to incrementing. +[5,4..1] -- [5, 4, 3, 2, 1] + +-- indexing into a list +[0..] !! 5 -- 5 + -- You can also have infinite lists in Haskell! [1..] -- a list of all the natural numbers @@ -84,15 +96,12 @@ not False -- True -- rest of the elements of this "infinite" list don't exist yet! Haskell won't -- actually evaluate them until it needs to. - - joining two lists +-- joining two lists [1..5] ++ [6..10] -- adding to the head of a list 0:[1..5] -- [0, 1, 2, 3, 4, 5] --- indexing into a list -[0..] !! 5 -- 5 - -- more list operations head [1..5] -- 1 tail [1..5] -- [2, 3, 4, 5] @@ -110,7 +119,7 @@ last [1..5] -- 5 -- A tuple: ("haskell", 1) --- accessing elements of a tuple +-- accessing elements of a pair (i.e. a tuple of length 2) fst ("haskell", 1) -- "haskell" snd ("haskell", 1) -- 1 @@ -131,7 +140,7 @@ add 1 2 -- 3 -- with backticks: 1 `add` 2 -- 3 --- You can also define functions that have no characters! This lets +-- You can also define functions that have no letters! This lets -- you define your own operators! Here's an operator that does -- integer division (//) a b = a `div` b @@ -139,12 +148,12 @@ add 1 2 -- 3 -- Guards: an easy way to do branching in functions fib x - | x < 2 = x + | x < 2 = 1 | otherwise = fib (x - 1) + fib (x - 2) -- Pattern matching is similar. Here we have given three different -- definitions for fib. Haskell will automatically call the first --- function that matches the pattern of the value. +-- function that matches the pattern of the value. fib 1 = 1 fib 2 = 2 fib x = fib (x - 1) + fib (x - 2) @@ -171,8 +180,8 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15 -- 4. More functions ---------------------------------------------------- --- currying: if you don't pass in all the arguments to a function, --- it gets "curried". That means it returns a function that takes the +-- partial application: if you don't pass in all the arguments to a function, +-- it gets "partially applied". That means it returns a function that takes the -- rest of the arguments. add a b = a + b @@ -193,16 +202,21 @@ foo = (*5) . (+10) foo 5 -- 75 -- fixing precedence --- Haskell has another function called `$`. This changes the precedence --- so that everything to the left of it gets computed first and then applied --- to everything on the right. You can use `.` and `$` to get rid of a lot --- of parentheses: +-- Haskell has another operator called `$`. This operator applies a function +-- to a given parameter. In contrast to standard function application, which +-- has highest possible priority of 10 and is left-associative, the `$` operator +-- has priority of 0 and is right-associative. Such a low priority means that +-- the expression on its right is applied as the parameter to the function on its left. -- before -(even (fib 7)) -- true +even (fib 7) -- false + +-- equivalently +even $ fib 7 -- false + +-- composing functions +even . fib $ 7 -- false --- after -even . fib $ 7 -- true ---------------------------------------------------- -- 5. Type signatures @@ -227,24 +241,24 @@ double :: Integer -> Integer double x = x * 2 ---------------------------------------------------- --- 6. Control Flow and If Statements +-- 6. Control Flow and If Expressions ---------------------------------------------------- --- if statements +-- if expressions haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" --- if statements can be on multiple lines too, indentation is important +-- if expressions can be on multiple lines too, indentation is important haskell = if 1 == 1 then "awesome" else "awful" --- case statements: Here's how you could parse command line arguments +-- case expressions: Here's how you could parse command line arguments case args of "help" -> printHelp "start" -> startProgram _ -> putStrLn "bad args" --- Haskell doesn't have loops because it uses recursion instead. +-- Haskell doesn't have loops; it uses recursion instead. -- map applies a function over every element in an array map (*2) [1..5] -- [2, 4, 6, 8, 10] @@ -269,7 +283,7 @@ foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 -- This is now the same as -(2 * 3 + (2 * 2 + (2 * 1 + 4))) +(2 * 1 + (2 * 2 + (2 * 3 + 4))) ---------------------------------------------------- -- 7. Data Types @@ -303,17 +317,17 @@ Nothing -- of type `Maybe a` for any `a` -- While IO can't be explained fully without explaining monads, -- it is not hard to explain enough to get going. --- When a Haskell program is executed, the function `main` is +-- When a Haskell program is executed, `main` is -- called. It must return a value of type `IO ()`. For example: main :: IO () -main = putStrLn $ "Hello, sky! " ++ (say Blue) +main = putStrLn $ "Hello, sky! " ++ (say Blue) -- putStrLn has type String -> IO () --- It is easiest to do IO if you can implement your program as --- a function from String to String. The function +-- It is easiest to do IO if you can implement your program as +-- a function from String to String. The function -- interact :: (String -> String) -> IO () --- inputs some text, runs a function on it, and prints out the +-- inputs some text, runs a function on it, and prints out the -- output. countLines :: String -> String @@ -327,43 +341,43 @@ main' = interact countLines -- the `do` notation to chain actions together. For example: sayHello :: IO () -sayHello = do +sayHello = do putStrLn "What is your name?" - name <- getLine -- this gets a line and gives it the name "input" + name <- getLine -- this gets a line and gives it the name "name" putStrLn $ "Hello, " ++ name - + -- Exercise: write your own version of `interact` that only reads -- one line of input. - + -- The code in `sayHello` will never be executed, however. The only --- action that ever gets executed is the value of `main`. --- To run `sayHello` comment out the above definition of `main` +-- action that ever gets executed is the value of `main`. +-- To run `sayHello` comment out the above definition of `main` -- and replace it with: -- main = sayHello --- Let's understand better how the function `getLine` we just +-- Let's understand better how the function `getLine` we just -- used works. Its type is: -- getLine :: IO String -- You can think of a value of type `IO a` as representing a --- computer program that will generate a value of type `a` +-- computer program that will generate a value of type `a` -- when executed (in addition to anything else it does). We can --- store and reuse this value using `<-`. We can also +-- store and reuse this value using `<-`. We can also -- make our own action of type `IO String`: action :: IO String action = do putStrLn "This is a line. Duh" - input1 <- getLine + input1 <- getLine input2 <- getLine -- The type of the `do` statement is that of its last line. - -- `return` is not a keyword, but merely a function + -- `return` is not a keyword, but merely a function return (input1 ++ "\n" ++ input2) -- return :: String -> IO String -- We can use this just like we used `getLine`: main'' = do putStrLn "I will echo two lines!" - result <- action + result <- action putStrLn result putStrLn "This was all, folks!" @@ -401,7 +415,9 @@ Hello, Friend! ``` -There's a lot more to Haskell, including typeclasses and monads. These are the big ideas that make Haskell such fun to code in. I'll leave you with one final Haskell example: an implementation of quicksort in Haskell: +There's a lot more to Haskell, including typeclasses and monads. These are the +big ideas that make Haskell such fun to code in. I'll leave you with one final +Haskell example: an implementation of quicksort in Haskell: ```haskell qsort [] = [] diff --git a/haxe.html.markdown b/haxe.html.markdown new file mode 100644 index 00000000..ee214540 --- /dev/null +++ b/haxe.html.markdown @@ -0,0 +1,788 @@ +--- +language: haxe +filename: LearnHaxe3.hx +contributors: + - ["Justin Donaldson", "https://github.com/jdonaldson/"] + - ["Dan Korostelev", "https://github.com/nadako/"] +--- + +Haxe is a web-oriented language that provides platform support for C++, C#, +Swf/ActionScript, Javascript, Java, and Neko byte code (also written by the +Haxe author). Note that this guide is for Haxe version 3. Some of the guide +may be applicable to older versions, but it is recommended to use other +references. + +```csharp +/* + Welcome to Learn Haxe 3 in 15 minutes. http://www.haxe.org + This is an executable tutorial. You can compile and run it using the haxe + compiler, while in the same directory as LearnHaxe.hx: + $> haxe -main LearnHaxe3 -x out + + Look for the slash-star marks surrounding these paragraphs. We are inside + a "Multiline comment". We can leave some notes here that will get ignored + by the compiler. + + Multiline comments are also used to generate javadoc-style documentation for + haxedoc. They will be used for haxedoc if they immediately precede a class, + class function, or class variable. + + */ + +// Double slashes like this will give a single-line comment + + +/* + This is your first actual haxe code coming up, it's declaring an empty + package. A package isn't necessary, but it's useful if you want to create a + namespace for your code (e.g. org.yourapp.ClassName). + + Omitting package declaration is the same as declaring an empty package. + */ +package; // empty package, no namespace. + +/* + Packages are directories that contain modules. Each module is a .hx file + that contains types defined in a package. Package names (e.g. org.yourapp) + must be lower case while module names are capitalized. A module contain one + or more types whose names are also capitalized. + + E.g, the class "org.yourapp.Foo" should have the folder structure org/module/Foo.hx, + as accessible from the compiler's working directory or class path. + + If you import code from other files, it must be declared before the rest of + the code. Haxe provides a lot of common default classes to get you started: + */ +import haxe.ds.ArraySort; + +// you can import many classes/modules at once with "*" +import haxe.ds.*; + +// you can import static fields +import Lambda.array; + +// you can also use "*" to import all static fields +import Math.*; + +/* + You can also import classes in a special way, enabling them to extend the + functionality of other classes like a "mixin". More on 'using' later. + */ +using StringTools; + +/* + Typedefs are like variables... for types. They must be declared before any + code. More on this later. + */ +typedef FooString = String; + +// Typedefs can also reference "structural" types, more on that later as well. +typedef FooObject = { foo: String }; + +/* + Here's the class definition. It's the main class for the file, since it has + the same name (LearnHaxe3). + */ +class LearnHaxe3{ + /* + If you want certain code to run automatically, you need to put it in + a static main function, and specify the class in the compiler arguments. + In this case, we've specified the "LearnHaxe3" class in the compiler + arguments above. + */ + static function main(){ + + /* + Trace is the default method of printing haxe expressions to the + screen. Different targets will have different methods of + accomplishing this. E.g., java, c++, c#, etc. will print to std + out. Javascript will print to console.log, and flash will print to + an embedded TextField. All traces come with a default newline. + Finally, It's possible to prevent traces from showing by using the + "--no-traces" argument on the compiler. + */ + trace("Hello World, with trace()!"); + + /* + Trace can handle any type of value or object. It will try to print + a representation of the expression as best it can. You can also + concatenate strings with the "+" operator: + */ + trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true); + + /* + In Haxe, it's required to separate expressions in the same block with + semicolons. But, you can put two expressions on one line: + */ + trace('two expressions..'); trace('one line'); + + + ////////////////////////////////////////////////////////////////// + // Types & Variables + ////////////////////////////////////////////////////////////////// + trace("***Types & Variables***"); + + /* + You can save values and references to data structures using the + "var" keyword: + */ + var an_integer:Int = 1; + trace(an_integer + " is the value for an_integer"); + + + /* + Haxe is statically typed, so "an_integer" is declared to have an + "Int" type, and the rest of the expression assigns the value "1" to + it. It's not necessary to declare the type in many cases. Here, + the haxe compiler is inferring that the type of another_integer + should be "Int". + */ + var another_integer = 2; + trace(another_integer + " is the value for another_integer"); + + // The $type() method prints the type that the compiler assigns: + $type(another_integer); + + // You can also represent integers with hexadecimal: + var hex_integer = 0xffffff; + + /* + Haxe uses platform precision for Int and Float sizes. It also + uses the platform behavior for overflow. + (Other numeric types and behavior are possible using special + libraries) + */ + + /* + In addition to simple values like Integers, Floats, and Booleans, + Haxe provides standard library implementations for common data + structures like strings, arrays, lists, and maps: + */ + + var a_string = "some" + 'string'; // strings can have double or single quotes + trace(a_string + " is the value for a_string"); + + /* + Strings can be "interpolated" by inserting variables into specific + positions. The string must be single quoted, and the variable must + be preceded with "$". Expressions can be enclosed in ${...}. + */ + var x = 1; + var an_interpolated_string = 'the value of x is $x'; + var another_interpolated_string = 'the value of x + 1 is ${x + 1}'; + + /* + Strings are immutable, instance methods will return a copy of + parts or all of the string. + (See also the StringBuf class). + */ + var a_sub_string = a_string.substr(0,4); + trace(a_sub_string + " is the value for a_sub_string"); + + /* + Regexes are also supported, but there's not enough space to go into + much detail. + */ + var re = ~/foobar/; + trace(re.match('foo') + " is the value for (~/foobar/.match('foo')))"); + + /* + Arrays are zero-indexed, dynamic, and mutable. Missing values are + defined as null. + */ + var a = new Array<String>(); // an array that contains Strings + a[0] = 'foo'; + trace(a.length + " is the value for a.length"); + a[9] = 'bar'; + trace(a.length + " is the value for a.length (after modification)"); + trace(a[3] + " is the value for a[3]"); //null + + /* + Arrays are *generic*, so you can indicate which values they contain + with a type parameter: + */ + var a2 = new Array<Int>(); // an array of Ints + var a3 = new Array<Array<String>>(); // an Array of Arrays (of Strings). + + /* + Maps are simple key/value data structures. The key and the value + can be of any type. + */ + var m = new Map<String, Int>(); // The keys are strings, the values are Ints. + m.set('foo', 4); + // You can also use array notation; + m['bar'] = 5; + trace(m.exists('bar') + " is the value for m.exists('bar')"); + trace(m.get('bar') + " is the value for m.get('bar')"); + trace(m['bar'] + " is the value for m['bar']"); + + var m2 = ['foo' => 4, 'baz' => 6]; // Alternative map syntax + trace(m2 + " is the value for m2"); + + /* + Remember, you can use type inference. The Haxe compiler will + decide the type of the variable the first time you pass an + argument that sets a type parameter. + */ + var m3 = new Map(); + m3.set(6, 'baz'); // m3 is now a Map<Int,String> + trace(m3 + " is the value for m3"); + + /* + Haxe has some more common datastructures in the haxe.ds module, such as + List, Stack, and BalancedTree + */ + + + ////////////////////////////////////////////////////////////////// + // Operators + ////////////////////////////////////////////////////////////////// + trace("***OPERATORS***"); + + // basic arithmetic + trace((4 + 3) + " is the value for (4 + 3)"); + trace((5 - 1) + " is the value for (5 - 1)"); + trace((2 * 4) + " is the value for (2 * 4)"); + trace((8 / 3) + " is the value for (8 / 3) (division always produces Floats)"); + trace((12 % 4) + " is the value for (12 % 4)"); + + + //basic comparison + trace((3 == 2) + " is the value for 3 == 2"); + trace((3 != 2) + " is the value for 3 != 2"); + trace((3 > 2) + " is the value for 3 > 2"); + trace((3 < 2) + " is the value for 3 < 2"); + trace((3 >= 2) + " is the value for 3 >= 2"); + trace((3 <= 2) + " is the value for 3 <= 2"); + + // standard bitwise operators + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed right shift + >>> Unsigned right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR + */ + + //increments + var i = 0; + trace("Increments and decrements"); + trace(i++); //i = 1. Post-Incrementation + trace(++i); //i = 2. Pre-Incrementation + trace(i--); //i = 1. Post-Decrementation + trace(--i); //i = 0. Pre-Decrementation + + ////////////////////////////////////////////////////////////////// + // Control Structures + ////////////////////////////////////////////////////////////////// + trace("***CONTROL STRUCTURES***"); + + // if statements + var j = 10; + if (j == 10){ + trace("this is printed"); + } else if (j > 10){ + trace("not greater than 10, so not printed"); + } else { + trace("also not printed."); + } + + // there is also a "ternary" if: + (j == 10) ? trace("equals 10") : trace("not equals 10"); + + /* + Finally, there is another form of control structures that operates + at compile time: conditional compilation. + */ +#if neko + trace('hello from neko'); +#elseif js + trace('hello from js'); +#else + trace('hello from another platform!'); +#end + /* + The compiled code will change depending on the platform target. + Since we're compiling for neko (-x or -neko), we only get the neko + greeting. + */ + + + trace("Looping and Iteration"); + + // while loop + var k = 0; + while(k < 100){ + // trace(counter); // will print out numbers 0-99 + k++; + } + + // do-while loop + var l = 0; + do{ + trace("do statement always runs at least once"); + } while (l > 0); + + // for loop + /* + There is no c-style for loop in Haxe, because they are prone + to error, and not necessary. Instead, Haxe has a much simpler + and safer version that uses Iterators (more on those later). + */ + var m = [1,2,3]; + for (val in m){ + trace(val + " is the value for val in the m array"); + } + + // Note that you can iterate on an index using a range + // (more on ranges later as well) + var n = ['foo', 'bar', 'baz']; + for (val in 0...n.length){ + trace(val + " is the value for val (an index for n)"); + } + + + trace("Array Comprehensions"); + + // Array comprehensions give you the ability to iterate over arrays + // while also creating filters and modifications. + var filtered_n = [for (val in n) if (val != "foo") val]; + trace(filtered_n + " is the value for filtered_n"); + + var modified_n = [for (val in n) val += '!']; + trace(modified_n + " is the value for modified_n"); + + var filtered_and_modified_n = [for (val in n) if (val != "foo") val += "!"]; + trace(filtered_and_modified_n + " is the value for filtered_and_modified_n"); + + ////////////////////////////////////////////////////////////////// + // Switch Statements (Value Type) + ////////////////////////////////////////////////////////////////// + trace("***SWITCH STATEMENTS (VALUE TYPES)***"); + + /* + Switch statements in Haxe are very powerful. In addition to working + on basic values like strings and ints, they can also work on the + generalized algebraic data types in enums (more on enums later). + Here's some basic value examples for now: + */ + var my_dog_name = "fido"; + var favorite_thing = ""; + switch(my_dog_name){ + case "fido" : favorite_thing = "bone"; + case "rex" : favorite_thing = "shoe"; + case "spot" : favorite_thing = "tennis ball"; + default : favorite_thing = "some unknown treat"; + // case _ : favorite_thing = "some unknown treat"; // same as default + } + // The "_" case above is a "wildcard" value + // that will match anything. + + trace("My dog's name is" + my_dog_name + + ", and his favorite thing is a: " + + favorite_thing); + + ////////////////////////////////////////////////////////////////// + // Expression Statements + ////////////////////////////////////////////////////////////////// + trace("***EXPRESSION STATEMENTS***"); + + /* + Haxe control statements are very powerful because every statement + is also an expression, consider: + */ + + // if statements + var k = if (true) 10 else 20; + + trace("k equals ", k); // outputs 10 + + var other_favorite_thing = switch(my_dog_name) { + case "fido" : "teddy"; + case "rex" : "stick"; + case "spot" : "football"; + default : "some unknown treat"; + } + + trace("My dog's name is" + my_dog_name + + ", and his other favorite thing is a: " + + other_favorite_thing); + + ////////////////////////////////////////////////////////////////// + // Converting Value Types + ////////////////////////////////////////////////////////////////// + trace("***CONVERTING VALUE TYPES***"); + + // You can convert strings to ints fairly easily. + + // string to integer + Std.parseInt("0"); // returns 0 + Std.parseFloat("0.4"); // returns 0.4; + + // integer to string + Std.string(0); // returns "0"; + // concatenation with strings will auto-convert to string. + 0 + ""; // returns "0"; + true + ""; // returns "true"; + // See documentation for parsing in Std for more details. + + + ////////////////////////////////////////////////////////////////// + // Dealing with Types + ////////////////////////////////////////////////////////////////// + + /* + + As mentioned before, Haxe is a statically typed language. All in + all, static typing is a wonderful thing. It enables + precise autocompletions, and can be used to thoroughly check the + correctness of a program. Plus, the Haxe compiler is super fast. + + *HOWEVER*, there are times when you just wish the compiler would let + something slide, and not throw a type error in a given case. + + To do this, Haxe has two separate keywords. The first is the + "Dynamic" type: + */ + var dyn: Dynamic = "any type of variable, such as this string"; + + /* + All that you know for certain with a Dynamic variable is that the + compiler will no longer worry about what type it is. It is like a + wildcard variable: You can pass it instead of any variable type, + and you can assign any variable type you want. + + The other more extreme option is the "untyped" keyword: + */ + + untyped { + var x:Int = 'foo'; // this can't be right! + var y:String = 4; // madness! + } + + /* + The untyped keyword operates on entire *blocks* of code, skipping + any type checks that might be otherwise required. This keyword should + be used very sparingly, such as in limited conditionally-compiled + situations where type checking is a hinderance. + + In general, skipping type checks is *not* recommended. Use the + enum, inheritance, or structural type models in order to help ensure + the correctness of your program. Only when you're certain that none + of the type models work should you resort to "Dynamic" or "untyped". + */ + + ////////////////////////////////////////////////////////////////// + // Basic Object Oriented Programming + ////////////////////////////////////////////////////////////////// + trace("***BASIC OBJECT ORIENTED PROGRAMMING***"); + + + /* + Create an instance of FooClass. The classes for this are at the + end of the file. + */ + var foo_instance = new FooClass(3); + + // read the public variable normally + trace(foo_instance.public_any + " is the value for foo_instance.public_any"); + + // we can read this variable + trace(foo_instance.public_read + " is the value for foo_instance.public_read"); + // but not write it + // foo_instance.public_read = 4; // this will throw an error if uncommented: + // trace(foo_instance.public_write); // as will this. + + // calls the toString method: + trace(foo_instance + " is the value for foo_instance"); + // same thing: + trace(foo_instance.toString() + " is the value for foo_instance.toString()"); + + + /* + The foo_instance has the "FooClass" type, while acceptBarInstance + has the BarClass type. However, since FooClass extends BarClass, it + is accepted. + */ + BarClass.acceptBarInstance(foo_instance); + + /* + The classes below have some more advanced examples, the "example()" + method will just run them here. + */ + SimpleEnumTest.example(); + ComplexEnumTest.example(); + TypedefsAndStructuralTypes.example(); + UsingExample.example(); + + } + +} + +/* + This is the "child class" of the main LearnHaxe3 Class + */ +class FooClass extends BarClass implements BarInterface{ + public var public_any:Int; // public variables are accessible anywhere + public var public_read (default, null): Int; // enable only public read + public var public_write (null, default): Int; // or only public write + public var property (get, set): Int; // use this style to enable getters/setters + + // private variables are not available outside the class. + // see @:allow for ways around this. + var _private:Int; // variables are private if they are not marked public + + // a public constructor + public function new(arg:Int){ + // call the constructor of the parent object, since we extended BarClass: + super(); + + this.public_any = 0; + this._private = arg; + + } + + // getter for _private + function get_property() : Int { + return _private; + } + + // setter for _private + function set_property(val:Int) : Int { + _private = val; + return val; + } + + // special function that is called whenever an instance is cast to a string. + public function toString(){ + return _private + " with toString() method!"; + } + + // this class needs to have this function defined, since it implements + // the BarInterface interface. + public function baseFunction(x: Int) : String{ + // convert the int to string automatically + return x + " was passed into baseFunction!"; + } +} + +/* + A simple class to extend +*/ +class BarClass { + var base_variable:Int; + public function new(){ + base_variable = 4; + } + public static function acceptBarInstance(b:BarClass){ + } +} + +/* + A simple interface to implement +*/ +interface BarInterface{ + public function baseFunction(x:Int):String; +} + +////////////////////////////////////////////////////////////////// +// Enums and Switch Statements +////////////////////////////////////////////////////////////////// + +/* + Enums in Haxe are very powerful. In their simplest form, enums + are a type with a limited number of states: + */ + +enum SimpleEnum { + Foo; + Bar; + Baz; +} + +// Here's a class that uses it: + +class SimpleEnumTest{ + public static function example(){ + var e_explicit:SimpleEnum = SimpleEnum.Foo; // you can specify the "full" name + var e = Foo; // but inference will work as well. + switch(e){ + case Foo: trace("e was Foo"); + case Bar: trace("e was Bar"); + case Baz: trace("e was Baz"); // comment this line to throw an error. + } + + /* + This doesn't seem so different from simple value switches on strings. + However, if we don't include *all* of the states, the compiler will + complain. You can try it by commenting out a line above. + + You can also specify a default for enum switches as well: + */ + switch(e){ + case Foo: trace("e was Foo again"); + default : trace("default works here too"); + } + } +} + +/* + Enums go much further than simple states, we can also enumerate + *constructors*, but we'll need a more complex enum example + */ +enum ComplexEnum{ + IntEnum(i:Int); + MultiEnum(i:Int, j:String, k:Float); + SimpleEnumEnum(s:SimpleEnum); + ComplexEnumEnum(c:ComplexEnum); +} +// Note: The enum above can include *other* enums as well, including itself! +// Note: This is what's called *Algebraic data type* in some other languages. + +class ComplexEnumTest{ + public static function example(){ + var e1:ComplexEnum = IntEnum(4); // specifying the enum parameter + /* + Now we can switch on the enum, as well as extract any parameters + it might of had. + */ + switch(e1){ + case IntEnum(x) : trace('$x was the parameter passed to e1'); + default: trace("Shouldn't be printed"); + } + + // another parameter here that is itself an enum... an enum enum? + var e2 = SimpleEnumEnum(Foo); + switch(e2){ + case SimpleEnumEnum(s): trace('$s was the parameter passed to e2'); + default: trace("Shouldn't be printed"); + } + + // enums all the way down + var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3))); + switch(e3){ + // You can look for certain nested enums by specifying them explicitly: + case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : { + trace('$i, $j, and $k were passed into this nested monster'); + } + default: trace("Shouldn't be printed"); + } + /* + Check out "generalized algebraic data types" (GADT) for more details + on why these are so great. + */ + } +} + +class TypedefsAndStructuralTypes { + public static function example(){ + /* + Here we're going to use typedef types, instead of base types. + At the top we've declared the type "FooString" to mean a "String" type. + */ + var t1:FooString = "some string"; + + /* + We can use typedefs for "structural types" as well. These types are + defined by their field structure, not by class inheritance. Here's + an anonymous object with a String field named "foo": + */ + + var anon_obj = { foo: 'hi' }; + + /* + The anon_obj variable doesn't have a type declared, and is an + anonymous object according to the compiler. However, remember back at + the top where we declared the FooObj typedef? Since anon_obj matches + that structure, we can use it anywhere that a "FooObject" type is + expected. + */ + + var f = function(fo:FooObject){ + trace('$fo was passed in to this function'); + } + f(anon_obj); // call the FooObject signature function with anon_obj. + + /* + Note that typedefs can have optional fields as well, marked with "?" + + typedef OptionalFooObj = { + ?optionalString: String, + requiredInt: Int + } + */ + + /* + Typedefs work well with conditional compilation. For instance, + we could have included this at the top of the file: + +#if( js ) + typedef Surface = js.html.CanvasRenderingContext2D; +#elseif( nme ) + typedef Surface = nme.display.Graphics; +#elseif( !flash9 ) + typedef Surface = flash8.MovieClip; +#elseif( java ) + typedef Surface = java.awt.geom.GeneralPath; +#end + + That would give us a single "Surface" type to work with across + all of those platforms. + */ + } +} + +class UsingExample { + public static function example() { + + /* + The "using" import keyword is a special type of class import that + alters the behavior of any static methods in the class. + + In this file, we've applied "using" to "StringTools", which contains + a number of static methods for dealing with String types. + */ + trace(StringTools.endsWith("foobar", "bar") + " should be true!"); + + /* + With a "using" import, the first argument type is extended with the + method. What does that mean? Well, since "endsWith" has a first + argument type of "String", that means all String types now have the + "endsWith" method: + */ + trace("foobar".endsWith("bar") + " should be true!"); + + /* + This technique enables a good deal of expression for certain types, + while limiting the scope of modifications to a single file. + + Note that the String instance is *not* modified in the run time. + The newly attached method is not really part of the attached + instance, and the compiler still generates code equivalent to a + static method. + */ + } + +} + +``` + +We're still only scratching the surface here of what Haxe can do. For a formal +overiew of all Haxe features, checkout the [online +manual](http://haxe.org/manual), the [online api](http://api.haxe.org/), and +"haxelib", the [haxe library repo] (http://lib.haxe.org/). + +For more advanced topics, consider checking out: + +* [Abstract types](http://haxe.org/manual/abstracts) +* [Macros](http://haxe.org/manual/macros), and [Compiler Macros](http://haxe.org/manual/macros_compiler) +* [Tips and Tricks](http://haxe.org/manual/tips_and_tricks) + + +Finally, please join us on [the mailing list](https://groups.google.com/forum/#!forum/haxelang), on IRC [#haxe on +freenode](http://webchat.freenode.net/), or on +[Google+](https://plus.google.com/communities/103302587329918132234). + + diff --git a/hu-hu/go.html.markdown b/hu-hu/go.html.markdown new file mode 100644 index 00000000..638c9489 --- /dev/null +++ b/hu-hu/go.html.markdown @@ -0,0 +1,337 @@ +--- +language: Go +lang: hu-hu +filename: learngo-hu.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] +translators: + - ["Szabó Krisztián", "https://github.com/thenonameguy/"] + - ["Árpád Goretity", "https://github.com/H2CO3"] +--- + +A Go programozási nyelv az életszerű feladatok könnyebb elvégzése miatt született. +A mai legújabb programozási trendeket elkerülve, +praktikus megoldást nyújt a valós, üzleti problémákra. + +C-szerű szintaktikával és statikus típuskezeléssel rendelkezik. +A fordító szempillantás alatt végez és egy gyorsan futó,statikus futtatható állományt hoz létre. +A nyelv könnyen érthető, folyamatok közötti csatornákon áthaladó üzenetekkel kommunikáló konkurens programozást tesz lehetővé, így könnyen ki lehet használni +a mai számítógépek több magos processzorait, ez nagy rendszerek építéséhez ideális. + +A Go alap könyvtára mindenre területre kiterjed, ennek köszönhetően a nyelvnek egyre növekvő tábora van. + +```go +// Egy soros komment +/* Több + soros komment */ + +// Minden forrás fájl egy csomag-definícióval kezdődik, ez hasonlít a Python +// csomagkezelésére +// A main egy különleges csomagnév, ennek a fordítása futtatható állományt hoz +// létre egy könyvtár helyett. +package main + +// Az import rész meghatározza melyik csomagokat kívánjuk használni ebben a +// forrásfájlban +import ( + "fmt" // A Go alap könyvtárának része + "net/http" // Beépített webszerver! + "strconv" // Stringek átalakítására szolgáló csomag +) + +// Függvénydeklarálás, a main nevű függvény a program kezdőpontja. +func main() { + // Println kiírja a beadott paramétereket a standard kimenetre. + // Ha más csomagot függvényeit akarjuk használni, akkor azt jelezni kell a + // csomag nevével + fmt.Println("Hello world!") + + // Meghívunk egy másik függvényt ebből a csomagból + beyondHello() +} + +// A függvények paraméterei zárójelek között vannak. +// Ha nincsenek paraméterek, akkor is kötelező a zárójel-pár. +func beyondHello() { + var x int // Változó deklaráció, használat előtt muszáj ezt megtenni. + x = 3 // Változó értékadás + // "Rövid" deklaráció is létezik, ez az érték alapján deklarálja, + // definiálja és értéket is ad a változónak + y := 4 + sum, prod := learnMultiple(x, y) // a függvényeknek több + // visszatérési értéke is lehet + fmt.Println("sum:", sum, "prod:", prod) // egyszerű kiíratás + learnTypes() +} + +// A funkcióknak elnevezett visszatérési értékük is lehet +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // visszatérünk két értékkel + /* + sum = x + y + prod = x * y + return + Ez ugyanezzel az eredménnyel járt volna, mint a fenti sor. + Üres return esetén, az elnevezett visszatérési változók + aktuális értékeikkel térnek vissza. */ +} + +// Beépített típusok +func learnTypes() { + // Rövid deklarálás az esetek többségében elég lesz a változókhoz + s := "Tanulj Go-t!" // string típus + + s2 := `A "nyers" stringekben lehetnek + újsorok is!` // de ettől még ez is ugyanolyan string mint az s, nincs külön + // típusa + + // nem ASCII karakterek. Minden Go forrás UTF-8 és a stringek is azok. + g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert + // tárol + + f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites + // lebegőpontos szám + c := 3 + 4i // complex128, belsőleg két float64-gyel tárolva + + // Var szintaxis változótípus-definiálással + var u uint = 7 // unsigned, az implementáció dönti el mekkora, akárcsak az + // int-nél + var pi float32 = 22. / 7 + + // Rövid deklarásnál átalakítás is lehetséges + n := byte('\n') // byte típus, ami megegyezik az uint8-al + + // A tömböknek fordítás-időben fixált méretük van + var a4 [4]int // egy tömb 4 int-tel, mind 0-ra inicializálva + a3 := [...]int{3, 1, 5} // egy tömb 3 int-tel, láthatóan inicalizálva egyedi + // értékekre + + // A "szeleteknek" (slices) dinamikus a méretük. A szeleteknek és a tömböknek is + // megvannak az előnyeik de a szeleteket sokkal gyakrabban használjuk. + s3 := []int{4, 5, 9} // vesd össze a3-mal, nincsenek pontok. + s4 := make([]int, 4) // allokál 4 int-et, mind 0-ra inicializálva + var d2 [][]float64 // ez csak deklaráció, semmi sincs még allokálva + bs := []byte("a slice") // típus konverzió szintaxisa + + p, q := learnMemory() // deklarál két mutatót (p,q), két int-re + fmt.Println(*p, *q) // * követi a mutatót. Ez a sor kiírja a két int értékét. + + // A map a dinamikusan növelhető asszociatív tömb része a nyelvnek, hasonlít + // a hash és dictionary típusokra más nyelvekben. + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + // A felhasználatlan változók fordítás-idejű hibát okoznak a Go-ban. + // Az aláhúzással "használod" a változókat, de eldobod az értéküket. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Kiíratás is természetesen használatnak minősül + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() +} + +// A Go nyelvben szemétgyűjtés (garbage collection) működik. Megtalálhatók benne +// mutatók, de nincs pointeraritmetika. Ez azt jelenti, hogy üres (null) mutatóval még +// mindig hibázhatsz, de hozzáadni/műveleteket végezni már nem lehet. +func learnMemory() (p, q *int) { + // Elnevezett visszatérési változóknak int-re mutató a típusa + p = new(int) // a beépített "new" funkció, egy típusnak elegendő memóriát + // allokál, és visszaad rá egy mutatót. + // Az allokált int nullázva van, p többé nem üres mutató. + s := make([]int, 20) // allokáljunk 20 int változót egy memóriaterületen. + s[3] = 7 // adjunk értéket az egyiknek + r := -2 // hozzánk létre egy lokális változót + return &s[3], &r // A & megadja a memóriacímét a változónak +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // Az elágazásoknak kötelező a kapcsos zárójel, a zárójel nem szükséges. + if true { + fmt.Println("megmondtam") + } + // A kód formátumát a nyelvvel járó "go" parancssori program "go fmt" + // parancsa szabványosítja + if false { + // így lehet + } else { + // if/else-t csinálni + } + // Használjunk switchet a hosszabb elágazások alkalmazása helyett. + x := 1 + switch x { + case 0: + case 1: + // Az "esetek" nem "esnek át", tehát + case 2: + // ez nem fog lefutni, nincs szükség break-ekre. + } + // A for ciklus sem használ zárójeleket + for x := 0; x < 3; x++ { + fmt.Println("iteráció", x) + } + // itt az x == 1. + + // A for az egyetlen ciklus fajta a Go-ban, de több formája van. + for { // végtelen ciklus + break // csak vicceltem + continue // soha nem fut le + } + + //Akárcsak a for-nál, az if-nél is lehet rövid deklarálással egy lokális változót létrehozni, + //ami a blokk összes if/else szerkezetén keresztül érvényes marad. + if y := expensiveComputation(); y > x { + x = y + } + // Függvényeket használhatjuk closure-ként is. + xBig := func() bool { + return x > 100 // a switch felett deklarált x-et használjuk itt + } + fmt.Println("xBig:", xBig()) // igaz (utoljára 1e6 lett az értéke az x-nek) + x /= 1e5 // így most már x == 10 + fmt.Println("xBig:", xBig()) // 10 pedig kisebb mint 100, tehát hamis + + // Ha nagyon-nagyon szükséges, akkor használhatjuk a jó öreg goto-t. + goto love +love: + + learnInterfaces() // Itt kezdődnek az érdekes dolgok! +} + +// Definiáljuk a Stringert egy olyan interfésznek, amelynek egy metódusa van, a +// String, ami visszatér egy stringgel. +type Stringer interface { + String() string +} + +// Definiáljuk a pair-t egy olyan struktúrának amelynek két int változója van, +// x és y. +type pair struct { + x, y int +} + +// Definiáljunk egy metódust a pair struktúrának, ezzel teljesítve a Stringer interfészt. +func (p pair) String() string { // p lesz a "fogadó" (receiver) + // Sprintf az fmt csomag egy publikus függvénye, műkődése megegyezik a C-s + // megfelelőjével. A pontokkal érjük el a mindenkori p struktúra elemeit + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // A kapcsos zárójellel jelezzük, hogy egyből inicializálni + // szeretnénk a struktúra változóit a sorrendnek megfelelően. + p := pair{3, 4} + fmt.Println(p.String()) // meghívjuk a p String metódusát. + var i Stringer // deklaráljuk i-t Stringer típusú interfésznek + i = p // lehetséges, mert a pair struktúra eleget tesz a + // Stringer interfésznek + // Meghívjuk i String metódusát, az eredmény ugyanaz, mint az előbb. + fmt.Println(i.String()) + + // Az fmt csomag függvényei automatikusan meghívják a String függvényt + // hogy megtudják egy objektum szöveges reprezentációját. + fmt.Println(p) // ugyan az az eredmény mint az előbb, a Println meghívja + // a String metódust. + fmt.Println(i) // dettó + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" szokásos megoldás arra, hogy jól működött-e a függvény. + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // ok hamis lesz, mert az 1 nincs benne a map-ban. + fmt.Println("nincs meg") + } else { + fmt.Print(x) // x lenne az érték, ha benne lenne a map-ban. + } + // A hiba érték többet is elmond a függvény kimeneteléről, mint hogy minden + // "ok" volt-e + if _, err := strconv.Atoi("non-int"); err != nil { // _ eldobja az értéket, + // úgy se lesz jó jelen + // esetben + // kiírja, hogy "strconv.ParseInt: parsing "non-int": invalid syntax" + fmt.Println(err) + } + // Az interfészekre még visszatérünk, addig is jöjjön a konkurens programozás! + learnConcurrency() +} + +// c egy csatorna, egy konkurens-biztos kommunikációs objektum. +func inc(i int, c chan int) { + c <- i + 1 // <- a "küldés" operátor, ha a bal oldalán csatorna van, így + // i+1-et küld be a csatornába +} + +// Az inc-et fogjuk arra használni, hogy konkurensen megnöveljünk számokat +func learnConcurrency() { + // Ugyanaz a make függvény, amivel korábban szeleteket hoztunk létre. + // A make allokál map-eket, szeleteket és csatornákat. + c := make(chan int) + // Indítsunk három konkurens goroutine-t. A számok konkurensen lesznek + // megnövelve, ha a számítógép képes rá és jól be van állítva, akkor pedig + // paralellizálva/egymás mellett. Mind a 3 ugyanabba a csatornába küldi az + // eredményeket. + go inc(0, c) // A go utasítás indít el goroutine-okat. + go inc(10, c) + go inc(-805, c) + // Beolvassuk 3x a csatornából az eredményeket és kiírjuk őket a kimenetre. + // Nem lehet tudni milyen sorrendben fognak érkezni az eredmények! + fmt.Println(<-c, <-c, <-c) // hogyha a jobb oldalon csatorna van, akkor a + // "<-" a beolvasó/kapó operátor + + cs := make(chan string) // még egy csatorna, ez stringekkel kommunikál + cc := make(chan chan string) // egy csatorna csatornával + go func() { c <- 84 }() // indítsunk egy új goroutine-t, csak azért + // hogy küldjünk egy számot + go func() { cs <- "wordy" }() // ugyanez, csak a cs csatornába stringet + // küldünk + // A select olyan mint a switch, csak feltételek helyett csatorna műveletek + // vannak. Véletlenszerűen kiválasztja az első olyan esetet, ahol létrejöhet + // kommunikáció. + select { + case i := <-c: // a megkapott értéket el lehet tárolni egy változóban + fmt.Println("ez egy", i) + case <-cs: // vagy el lehet dobni az értékét + fmt.Println("ez egy string volt") + case <-cc: // üres csatorna, soha nem fog rajta semmi se érkezni + fmt.Println("sose futok le :'( ") + } + // Ezen a ponton vagy c vagy a cs goroutine-ja lefutott. + // Amelyik hamarabb végzett, annak a megfelelő case-e lefutott, a másik + // blokkolva vár. + + learnWebProgramming() // a Go képes rá. Te is képes akarsz rá lenni. +} + +// Egy függvény a http csomagból elindít egy webszervert. +func learnWebProgramming() { + // A ListenAndServe első paramétre egy TCP port, amin kiszolgálunk majd. + // Második paramétere egy interfész, pontosabban a http.Handler interfész. + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // nem felejtjük el kiírni az esetleges hibákat! +} + +// Csináljunk a pair-ból egy http.Handler-t úgy, hogy implementáljuk az +// egyetlen metódusát, a ServeHTTP-t. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Minden kapcsolatra elküldjük ezt a http.ResponseWriter-rel + w.Write([]byte("Megtanultad a Go-t Y perc alatt!")) +} +``` + +## További olvasmányok + +Minden Go-val kapcsolatos megtaláható a [hivatalos Go weboldalon](http://golang.org/). +Ott követhetsz egy tutorialt, játszhatsz a nyelvvel az interneten, és sok érdekességet olvashatsz. + +A nyelv specifikációját kifejezetten érdemes olvasni, viszonylag rövid és sokat tanul belőle az ember. + +Ha pedig jobban bele akarod vetni magad a Go-ba, akkor a legjobb praktikákat kilesheted a standard könyvtárból. +TIPP: a dokumentációban kattints egy függvény nevére és rögtön megmutatja a hozzá tartozó kódot! + +Ha pedig a nyelvnek egy bizonyos részéről szeretnél hasonló leírást találni, akkor a +[gobyexample.com](https://gobyexample.com/)-on megtalálod, amit keresel. diff --git a/hy.html.markdown b/hy.html.markdown new file mode 100644 index 00000000..9beaff0c --- /dev/null +++ b/hy.html.markdown @@ -0,0 +1,174 @@ +--- +language: hy +filename: learnhy.hy +contributors: + - ["Abhishek L", "http://twitter.com/abhishekl"] +--- + +Hy is a lisp dialect built on top of python. This is achieved by +converting hy code to python's abstract syntax tree (ast). This allows +hy to call native python code or python to call native hy code as well + +This tutorial works for hy ≥ 0.9.12 + +```clojure +;; this gives an gentle introduction to hy for a quick trial head to +;; http://try-hy.appspot.com +;; +; Semicolon comments, like other LISPS + +;; s-expression basics +; lisp programs are made of symbolic expressions or sexps which +; resemble +(some-function args) +; now the quintessential hello world +(print "hello world") + +;; simple data types +; All simple data types are exactly similar to their python counterparts +; which +42 ; => 42 +3.14 ; => 3.14 +True ; => True +4+10j ; => (4+10j) a complex number + +; lets start with some really simple arithmetic +(+ 4 1) ;=> 5 +; the operator is applied to all arguments, like other lisps +(+ 4 1 2 3) ;=> 10 +(- 2 1) ;=> 1 +(* 4 2) ;=> 8 +(/ 4 1) ;=> 4 +(% 4 2) ;=> 0 the modulo operator +; power is represented by ** operator like python +(** 3 2) ;=> 9 +; nesting forms will do the expected thing +(+ 2 (* 4 2)) ;=> 10 +; also logical operators and or not and equal to etc. do as expected +(= 5 4) ;=> False +(not (= 5 4)) ;=> True + +;; variables +; variables are set using setv, variable names can use utf-8 except +; for ()[]{}",'`;#| +(setv a 42) +(setv π 3.14159) +(def *foo* 42) +;; other container data types +; strings, lists, tuples & dicts +; these are exactly same as python's container types +"hello world" ;=> "hello world" +; string operations work similar to python +(+ "hello " "world") ;=> "hello world" +; lists are created using [], indexing starts at 0 +(setv mylist [1 2 3 4]) +; tuples are immutable data structures +(setv mytuple (, 1 2)) +; dictionaries are key value pairs +(setv dict1 {"key1" 42 "key2" 21}) +; :name can be used to define keywords in hy which can be used for keys +(setv dict2 {:key1 41 :key2 20}) +; use `get' to get the element at an index/key +(get mylist 1) ;=> 2 +(get dict1 "key1") ;=> 42 +; Alternatively if keywords were used they can directly be called +(:key1 dict2) ;=> 41 + +;; functions and other program constructs +; functions are defined using defn, the last sexp is returned by default +(defn greet [name] + "A simple greeting" ; an optional docstring + (print "hello " name)) + +(greet "bilbo") ;=> "hello bilbo" + +; functions can take optional arguments as well as keyword arguments +(defn foolists [arg1 &optional [arg2 2]] + [arg1 arg2]) + +(foolists 3) ;=> [3 2] +(foolists 10 3) ;=> [10 3] + +; anonymous functions are created using `fn' or `lambda' constructs +; which are similiar to `defn' +(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16] + +;; Sequence operations +; hy has some builtin utils for sequence operations etc. +; retrieve the first element using `first' or `car' +(setv mylist [1 2 3 4]) +(setv mydict {"a" 1 "b" 2}) +(first mylist) ;=> 1 + +; slice lists using slice +(slice mylist 1 3) ;=> [2 3] + +; get elements from a list or dict using `get' +(get mylist 1) ;=> 2 +(get mydict "b") ;=> 2 +; list indexing starts from 0 same as python +; assoc can set elements at keys/indexes +(assoc mylist 2 10) ; makes mylist [1 2 10 4] +(assoc mydict "c" 3) ; makes mydict {"a" 1 "b" 2 "c" 3} +; there are a whole lot of other core functions which makes working with +; sequences fun + +;; Python interop +;; import works just like in python +(import datetime) +(import [functools [partial reduce]]) ; imports fun1 and fun2 from module1 +(import [matplotlib.pyplot :as plt]) ; doing an import foo as bar +; all builtin python methods etc. are accessible from hy +; a.foo(arg) is called as (.foo a arg) +(.split (.strip "hello world ")) ;=> ["hello" "world"] + +;; Conditionals +; (if condition (body-if-true) (body-if-false) +(if (= passcode "moria") + (print "welcome") + (print "Speak friend, and Enter!")) + +; nest multiple if else if clauses with cond +(cond + [(= someval 42) + (print "Life, universe and everything else!")] + [(> someval 42) + (print "val too large")] + [(< someval 42) + (print "val too small")]) + +; group statements with do, these are executed sequentially +; forms like defn have an implicit do +(do + (setv someval 10) + (print "someval is set to " someval)) ;=> 10 + +; create lexical bindings with `let', all variables defined thusly +; have local scope +(let [[nemesis {"superman" "lex luther" + "sherlock" "moriarty" + "seinfeld" "newman"}]] + (for [(, h v) (.items nemesis)] + (print (.format "{0}'s nemesis was {1}" h v)))) + +;; classes +; classes are defined in the following way +(defclass Wizard [object] + [[--init-- (fn [self spell] + (setv self.spell spell) ; init the spell attr + None)] + [get-spell (fn [self] + self.spell)]]) + +;; do checkout hylang.org +``` + +### Further Reading + +This tutorial is just a very basic introduction to hy/lisp/python. + +Hy docs are here: [http://hy.readthedocs.org](http://hy.readthedocs.org) + +Hy's Github repo: [http://github.com/hylang/hy](http://github.com/hylang/hy) + +On freenode irc #hy, twitter hashtag #hylang diff --git a/id-id/css-id.html.markdown b/id-id/css-id.html.markdown new file mode 100644 index 00000000..456dfafe --- /dev/null +++ b/id-id/css-id.html.markdown @@ -0,0 +1,246 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] +translators: + - ["Eka Y Saputra", "http://github.com/ekajogja"] +lang: id-id +filename: learncss-id.css +--- + +Pada mulanya, web tidak memiliki elemen visual, murni teks saja. +Tapi seiring perkembangan peramban, laman web dengan elemen visual menjadi umum. +CSS adalah bahasa standar yang ada untuk menjaga keterpisahan antara +konten (HTML) serta tampilan-dan-kesan laman web. + +Singkatnya, fungsi CSS ialah menyajikan sintaks yang memampukan kita +untuk memilih elemen tertentu dalam sebuah laman HTML +dan menerapkan berbagai properti visual bagi elemen tersebut. + +Seperti bahasa lainnya, CSS memiliki banyak versi. +Di artikel ini, kita fokus pada CSS2.0 - yang meskipun bukan versi termutakhir +namun paling kompatibel dan didukung secara luas. + +**CATATAN:** Lantaran keluaran dari CSS berwujud efek-efek visual, +maka untuk mempelajarinya, kita perlu mencoba berbagai hal dalam dunia olah CSS +semisal [dabblet](http://dabblet.com/). +Fokus utama artikel ini ialah pada sintaks dan sejumlah tips umum. + + +```css +/* komentar terletak diantara sepasang tanda garis miring dan bintang, +persis seperti larik ini! */ + +/* #################### + ## SELEKTOR + ####################*/ + +/* Secara garis besar, statemen utama dalam CSS sangat sederhana */ +selektor { properti: nilai; /* properti lainnya */ } + +/* selektor berfungsi untuk memilih suatu elemen dalam sebuah laman. + +Kita juga bisa memilih semua elemen di sebuah halaman! */ +* { color:red; } + +/* +Dengan menentukan sebuah elemen seperti ini pada sebuah laman: + +<div class='suatu-class class2' id='suatuId' attr='nilai' /> +*/ + +/* kita bisa memilih elemen berdasarkan nama class-nya */ +.suatu-class { } + +/*atau dengan dua class sekaligus! */ +.suatu-class.class2 { } + +/* atau dengan nama tag-nya */ +div { } + +/* atau id-nya */ +#suatuId { } + +/* atau - jika ada - dengan attribute-nya! */ +[attr] { font-size:smaller; } + +/* atau jika attribute tersebut memiliki nilai spesifik */ +[attr='nilai'] { font-size:smaller; } + +/* dibuka dengan sebuah nilai*/ +[attr^='nil'] { font-size:smaller; } + +/* atau ditutup dengan nilai */ +[attr$='ai'] { font-size:smaller; } + +/* atau bahkan disisipi nilai */ +[attr~='la'] { font-size:smaller; } + + +/* dan yang lebih penting lagi, kita bisa mengombinasikannya sekaligus +dengan syarat tidak ada spasi diantara selektor-selektor. sebab adanya spasi +akan membuat selektor itu memiliki makna yang berbeda.*/ +div.suatu-class[attr$='ai'] { } + +/* kita juga bisa memilih sebuah elemen berdasarkan posisi elemen induknya.*/ + +/*sebuah elemen yang merupakan anak langsung dari elemen induk (diseleksi dng +cara yang sama) */ +div.suatu-induk > .-suatu-class {} + +/* atau salah satu induk elemennya dalam hirarki elemen */ +/* berikut ini dimaksudkan pada elemen manapun dengan class "class-entah" dan +merupakan anak elemen dari suatu div dengan class "induk-entah" PADA LEVEL +HIRARKI MANAPUN */ +div.suatu-induk .suatu-class {} + +/* peringatan: selektor yang sama jika tanpa ada spasi akan bermakna lain. +misalnya? */ +div.suatu-induk.suatu-class {} + +/* kita juga bisa memilih sebuah elemen berdasarkan saudara elemen yang muncul +tepat sebelumnya */ +.aku-muncul-tepat-sebelum + .elemen-ini { } + +/*atau saudara elemen manapun yang pernah muncul selang beberapa elemen +sebelumnya */ +.aku-pernah-muncul-sebelum ~ .elemen-ini {} + +/* Ada beberapa pseudo-class yang memampukan kita memilih suatu elemen +berdasarkan perilaku lamannya (bukan struktur lamannya) */ + +/* semisal ketika sebuah elemen ditimpa hover (pointer mouse) */ +:hover {} + +/* atau link yang sudah pernah diklik*/ +:visited {} + +/* atau link yang belum pernah diklik*/ +:link {} + +/* atau elemen input yang menjadi fokus */ +:focus {} + + +/* #################### + ## PROPERTI + ####################*/ + +selektor { + + /* Unit */ + width: 50%; /* dalam persen */ + font-size: 2em; /* angka kali jumlah font-size saat ini */ + width: 200px; /* dalam pixel */ + font-size: 20pt; /* dalam point */ + width: 5cm; /* dalam centimeter */ + width: 50mm; /* dalam milimeter */ + width: 5in; /* dalam inci */ + + /* Warna */ + background-color: #F6E; /* dalam short hex */ + background-color: #F262E2; /* dalam format long hex */ + background-color: tomato; /* warna yang sudah punya konvensi nama */ + background-color: rgb(255, 255, 255); /* dalam rgb */ + background-color: rgb(10%, 20%, 50%); /* dalam persen rgb */ + background-color: rgba(255, 0, 0, 0.3); /* dalam rgb semi-transparan*/ + + /* Gambar */ + background-image: url(/folder-gambar/image.jpg); + + /* Font */ + font-family: Arial; + font-family: "Courier New"; /* jika nama font memiliki spasi, + ia diketik dalam tanda petik ganda */ + font-family: "Courier New", Trebuchet, Arial; /* jika font pertama tidak + ditemukan, peramban menggunakan font berikutnya, + demikian secara berturut-turut */ +} + +``` + +## Penggunaan + +Simpan semua CSS yang hendak kita pakai dengan ekstensi `.css`. + +```xml +<!-- kita harus menautkan file css itu ke laman di bagian <head>: --> +<link rel='stylesheet' type='text/css' href='folder/namafile.css' /> + +<!-- kita juga bisa mengetik CSS secara inline di dalam markup. +Namun, sebisa mungkin metode ini dihindari. --> +<style> + selektor { properti:nilai; } +</style> + +<!-- atau langsung mengetik properti CSS pada sebuah elemen. +Metode ini harus dihindari sebisa mungkin. --> +<div style='properti:nilai;'> +</div> + +``` + +## Prioritas + +Kita tahu bahwa sebuah elemen bisa dipilih dengan lebih dari satu selektor, +serta bisa diberi lebih dari satu properti. +Dalam kasus seperti ini, hanya salah satu properti saja yang akan diterapkan +pada elemen dengan prioritas tertentu. + +Dengan susunan CSS: + +```css + +/*A*/ +p.class1[attr='nilai'] + +/*B*/ +p.class1 {} + +/*C*/ +p.class2 {} + +/*D*/ +p {} + +/*E*/ +p { properti: nilai !important; } + +``` + +dan susunan markup: + +```xml +<p style='/*F*/ properti:nilai;' class='class1 class2' attr='nilai'> +</p> +``` + +Maka prioritas penerapan style-nya ialah sbb.: +Ingat, penerapan ini untuk masing-masing **properti**, +bukan keseluruhan larik. + +* `E` prioritas pertama sebab ada kata `!important`. + Dianjurkan untuk menghindari kata ini jika tidak benar-benar perlu. +* `F` prioritas kedua sebab ia diketik secara inline. +* `A` prioritas ketiga sebab selektor ini lebih spesifik dibanding yang lain. + lebih spesifik = lebih banyak unsur selektor. contoh ini punya 3 unsur: + 1 tagname `p` + 1 nama class `class1` + 1 attribute `attr='nilai'` +* `C` prioritas berikutnya sebab meski sama spesifik dengan `B` namun + ia muncul lebih akhir. +* Lalu `B` +* dan terakhir baru `D`. + +## Kompatibilitas + +Sebagian besar fitur dalam CSS2 (dan lambat laun juga CSS3) kompatibel dengan +semua peramban dan perangkat. Namun selalu vital untuk memastikan kompatibilitas +unsur dan nilai yang kita ketikkan dalam CSS dengan peramban yang ditargetkan. + +[QuirksMode CSS](http://www.quirksmode.org/css/) ialah salah satu sumber terbaik untuk memeriksa kompatibilitas CSS dan peramban. + +## Referensi Lanjut + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) + diff --git a/id-id/json-id.html.markdown b/id-id/json-id.html.markdown new file mode 100644 index 00000000..52e61449 --- /dev/null +++ b/id-id/json-id.html.markdown @@ -0,0 +1,60 @@ +--- +language: json +filename: learnjson.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators + - ["Rizky Luthfianto", "https://github.com/rilut"] +--- + +JSON adalah format pertukaran data yang sangat simpel, kemungkinan besar, +ini adalah "Learn X in Y Minutes" yang paling singkat. + +Murninya, JSON tidak mempunyai fitur komentar, tapi kebanyakan parser akan +menerima komentar bergaya bahasa C (`//`, `/* */`). Namun, pada halaman ini, +hanya dicontohkan JSON yang 100% valid. + +```json +{ + "kunci": "nilai", + + "kunci": "harus selalu diapit tanda kutip", + "angka": 0, + "strings": "Halø, dunia. Semua karaktor unicode diperbolehkan, terumasuk \"escaping\".", + "punya tipe data boolean?": true, + "nilai kosong": null, + + "angka besar": 1.2e+100, + + "obyek": { + "komentar": "Most of your structure will come from objects.", + + "array": [0, 1, 2, 3, "Array bisa berisi apapun.", 5], + + "obyek lainnya": { + "komentar": "Obyek-obyek JSON dapat dibuat bersarang, sangat berguna." + } + }, + + "iseng-iseng": [ + { + "sumber potassium": ["pisang"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "gaya alternatif": { + "komentar": "lihat ini!" + , "posisi tanda koma": "tak masalah. selama sebelum nilai berikutnya, valid-valid saja" + , "komentar lainnya": "betapa asyiknya" + }, + + "singkat": "Dan Anda selesai! Sekarang Anda tahu apa saja yang disediakan oleh JSON." +} +``` diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown new file mode 100644 index 00000000..c1e985aa --- /dev/null +++ b/id-id/xml-id.html.markdown @@ -0,0 +1,130 @@ +--- +language: xml +filename: learnxml.xml +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. + +Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, hanya membawanya. + +* Sintaks XML + +```xml +<!-- Komentar di XML seperti ini --> + +<?xml version="1.0" encoding="UTF-8"?> +<tokobuku> + <buku category="MEMASAK"> + <judul lang="en">Everyday Italian</judul> + <pengarang>Giada De Laurentiis</pengarang> + <tahun>2005</tahun> + <harga>30.00</harga> + </buku> + <buku category="ANAK"> + <judul lang="en">Harry Potter</judul> + <pengarang>J K. Rowling</pengarang> + <tahun>2005</tahun> + <harga>29.99</harga> + </buku> + <buku category="WEB"> + <judul lang="en">Learning XML</judul> + <pengarang>Erik T. Ray</pengarang> + <tahun>2003</tahun> + <harga>39.95</harga> + </buku> +</tokobuku> + +<!-- Di atas adalah contoh file XML biasa. + Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional). + + XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku', + yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki + node-node anak, dan seterusnya ... + + Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya + berada di antara tag buka dan tutup .--> + + +<!-- XML membawa dua jenis data: + 1 - Atribut -> Itu metadata tentang sebuah node. + Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan + benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag. + 2 - Elemen -> Itu data yang murni. + Itulah yang parser akan mengambil dari file XML. + Elemen muncul antara tag membuka dan menutup.--> + + +<!-- Di bawah ini, unsur dengan dua atribut--> +<file type="gif" id="4293">komputer.gif</file> + + +``` + +* Dokumen yang well-formated & Validasi + +Sebuah dokumen XML disebut well-formated jika sintaksisnya benar. +Namun, juga mungkin untuk mendefinisikan lebih banyak batasan dalam dokumen, +menggunakan definisi dokumen, seperti DTD dan XML Schema. + +Sebuah dokumen XML yang mengikuti definisi dokumen disebut valid, +jika sesuai dokumen itu. + +Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi. + +```xml + +<!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku, + dengan penambahan definisi DTD .--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE catatan SYSTEM "tokobuku.dtd"> +<tokobuku> + <buku category="MEMASAK"> + <judul >Everyday Italian</judul> + <harga>30.00</harga> + </buku> +</tokobuku> + +<!-- This DTD could be something like:--> + +<!DOCTYPE catatan +[ +<!ELEMENT tokobuku (buku+)> +<!ELEMENT buku (judul,harga)> +<!ATTLIST buku category CDATA "Sastra"> +<!ELEMENT judul (#PCDATA)> +<!ELEMENT harga (#PCDATA)> +]> + + +<!-- DTD dimulai dengan deklarasi. + Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'. + Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut + disebut 'kategori', dengan "Sastra" sebagai nilai default. + Node yang 'judul' dan 'harga' mengandung karakter data diurai .--> + +<!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE catatan +[ +<!ELEMENT tokobuku (buku+)> +<!ELEMENT buku (judul,harga)> +<!ATTLIST buku category CDATA "Sastra"> +<!ELEMENT judul (#PCDATA)> +<!ELEMENT harga (#PCDATA)> +]> + +<tokobuku> + <buku category="MEMASAK"> + <judul >Everyday Italian</judul> + <harga>30.00</harga> + </buku> +</tokobuku> +``` diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown new file mode 100644 index 00000000..f892845f --- /dev/null +++ b/it-it/bash-it.html.markdown @@ -0,0 +1,275 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] +filename: LearnBash.sh +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it +--- + +Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X. +Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell. + +[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# La prima riga dello script è lo shebang il quale dice al sistema come eseguire +# lo script: http://it.wikipedia.org/wiki/Shabang +# Come avrai già immaginato, i commenti iniziano con #. Lo shebang stesso è un commento. + +# Semplice esempio ciao mondo: +echo Ciao mondo! + +# Ogni comando inizia su una nuova riga, o dopo un punto e virgola: +echo 'Questa è la prima riga'; echo 'Questa è la seconda riga' + +# Per dichiarare una variabile: +VARIABILE="Una stringa" + +# Ma non così: +VARIABILE = "Una stringa" +# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore +# perchè non esiste. + +# Usare la variabile: +echo $VARIABILE +echo "$VARIABILE" +echo '$VARIABILE' +# Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi +# il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $. +# Nota che ' (singolo apice) non espande le variabili! + +# Sostituzione di stringhe nelle variabili +echo ${VARIABILE/Una/A} +# Questo sostituirà la prima occorrenza di "Una" con "La" + +# Sottostringa di una variabile +echo ${VARIABILE:0:7} +# Questo ritornerà solamente i primi 7 caratteri + +# Valore di default per la variabile +echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"} +# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0 + +# Variabili builtin: +# Ci sono delle variabili builtin molto utili, come +echo "Valore di ritorno dell'ultimo programma eseguito: $?" +echo "PID dello script: $$" +echo "Numero di argomenti: $#" +echo "Argomenti dello script: $@" +echo "Argomenti dello script separati in variabili distinte: $1 $2..." + +# Leggere un valore di input: +echo "Come ti chiami?" +read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile +echo Ciao, $NOME! + +# Classica struttura if: +# usa 'man test' per maggiori informazioni sulle condizionali +if [ $NOME -ne $USER ] +then + echo "Il tuo nome non è lo username" +else + echo "Il tuo nome è lo username" +fi + +# C'è anche l'esecuzione condizionale +echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce" +echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce" + +# Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre: +if [ $NOME == "Steve" ] && [ $ETA -eq 15 ] +then + echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15." +fi + +if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ] +then + echo "Questo verrà eseguito se $NAME è Daniya O Zach." +fi + +# Le espressioni sono nel seguente formato: +echo $(( 10 + 5 )) + +# A differenza di altri linguaggi di programmazione, bash è una shell - quindi lavora nel contesto +# della cartella corrente. Puoi elencare i file e le cartelle nella cartella +# corrente con il comando ls: +ls + +# Questi comandi hanno opzioni che controllano la loro esecuzione: +ls -l # Elenca tutti i file e le cartelle su una riga separata + +# I risultati del comando precedente possono essere passati al comando successivo come input. +# Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i +# file .txt nella cartella corrente: +ls -l | grep "\.txt" + +# Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr). +# Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe +# comprese tra "EOF": +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Esegui hello.py con diverse redirezioni stdin, stdout, e stderr: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# Lo output error sovrascriverà il file se esiste, +# se invece vuoi appendere usa ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Sovrascrivi output.txt, appendi a error.err, e conta le righe: +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Esegui un comando e stampa il suo file descriptor (esempio: /dev/fd/123) +# vedi: man fd +echo <(echo "#ciaomondo") + +# Sovrascrivi output.txt con "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva) +rm -v output.out error.err output-and-error.log + +# I comandi possono essere sostituiti con altri comandi usando $( ): +# Il comando seguente mostra il numero di file e cartelle nella +# cartella corrente. +echo "Ci sono $(ls | wc -l) oggetti qui." + +# Lo stesso puo' essere usato usando backticks `` ma non possono essere innestati - il modo migliore +# è usando $( ). +echo "Ci sono `ls | wc -l` oggetti qui." + +# Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++: +case "$VARIABILE" in + #Lista di pattern per le condizioni che vuoi soddisfare + 0) echo "C'è uno zero.";; + 1) echo "C'è un uno.";; + *) echo "Non è null.";; +esac + +# I cicli for iterano per ogni argomento fornito: +# I contenuti di $VARIABILE sono stampati tre volte. +for VARIABILE in {1..3} +do + echo "$VARIABILE" +done + +# O scrivilo con il "ciclo for tradizionale": +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Possono essere usati anche per agire su file.. +# Questo eseguirà il comando 'cat' su file1 e file2 +for VARIABILE in file1 file2 +do + cat "$VARIABILE" +done + +# ..o dall'output di un comando +# Questo eseguirà cat sull'output di ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# while loop: +while [ true ] +do + echo "corpo del loop..." + break +done + +# Puoi anche definire funzioni +# Definizione: +function foo () +{ + echo "Gli argomenti funzionano come gli argomenti dello script: $@" + echo "E: $1 $2..." + echo "Questa è una funzione" + return 0 +} + +# o semplicemente +bar () +{ + echo "Un altro modo per dichiarare funzioni!" + return 0 +} + +# Per chiamare la funzione +foo "Il mio nome è" $NOME + +# Ci sono un sacco di comandi utili che dovresti imparare: +# stampa le ultime 10 righe di file.txt +tail -n 10 file.txt +# stampa le prime 10 righe di file.txt +head -n 10 file.txt +# ordina le righe di file.txt +sort file.txt +# riporta o ometti le righe ripetute, con -d le riporta +uniq -d file.txt +# stampa solamente la prima colonna prima del carattere ',' +cut -d ',' -f 1 file.txt +# sostituisce ogni occorrenza di 'okay' con 'great' in file.txt (compatible con le regex) +sed -i 's/okay/great/g' file.txt +# stampa su stdout tutte le righe di file.txt che soddisfano una certa regex +# L'esempio stampa le righe che iniziano con "foo" e che finiscono con "bar" +grep "^foo.*bar$" file.txt +# passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex +grep -c "^foo.*bar$" file.txt +# se vuoi letteralmente cercare la stringa, +# e non la regex, usa fgrep (o grep -F) +fgrep "^foo.*bar$" file.txt + + +# Leggi la documentazione dei builtin di bash con il builtin 'help' di bash: +help +help help +help for +help return +help source +help . + +# Leggi la manpage di bash con man +apropos bash +man 1 bash +man bash + +# Leggi la documentazione con info (? per help) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Leggi la documentazione di bash: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown new file mode 100644 index 00000000..4999d7e6 --- /dev/null +++ b/it-it/brainfuck-it.html.markdown @@ -0,0 +1,101 @@ +--- + +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Ivan Sala", "http://slavni96.github.io/"] +lang: it-it + +--- + +Brainfuck è un linguaggio di programmazione estremamente minimale, +ma è ingrado di rappresentare completamente una macchina di turnig, +e sfrutta solo 8 caratteri. +[Per saperne di più](http://it.wikipedia.org/wiki/Brainfuck) + +``` + +Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) +viene ignorato. +Branfuck è caratterizzato da un array (vettore) di 30,000 celle +inizializzare a zero, e un puntatore che punta alla cella corrente. + +Vi sono solo otto comando: ++ : Incrementa il valore della cella attuale di uno. +- : Decrementa il valore della cella attuale di uno. +> : Sposta il puntatore sulla cella seguente (prossima a destra). +< : Sposta il puntatore sulla cella precendete (precedente a sinistra). +. : Stampa il valore in ASCII della cella corrente. (es: 65 = 'A') +, : Legge un singolo carattere come input per la cella corrente. +[ : Se il valore della cella corrente è zero, conclude il ciclo + andando alla sua corrispondente ]. + Altrimenti, passa alla prossima istruzione. +] : Se il valore della cella corrente è zero, passa alla prossima istruzione. + Altrimenti torna indetro fino alla [ corrispondente. + +[ e ] creano un loop (while). Ovviamente dovranno essere bilanciati. +Per ogni [ dovrà corrispondere una ] + +Alcuni semplici esempi di programmi scritti in Brainfuck: + +++++++ [ > ++++++++++ < - ] > +++++ . + +Questo programma stampa in output la lettera 'A'. Priam incrementa +la cella #1 fino a 6, Quindi la cella #1 viene usata per crare un ciclo. +Poi, entra in un loop ([) e si sposta alla cella #2. +Incrementa la cella #2 10 volte, e torna alla cella #1, e la decrementa. +Questo avviene 6 volte (servono che la cella #1 venga decrementata 6 volte +per raggiungere lo 0. Quindi passa alla corrispondente ] e prosegue). + +A questo punto, siamo sulla cella #1, che ha valore 0, +la cella #2 ha valore 60 (6*10). Ci spostiamo sulla cella #2, incrementiamo +per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella +#2 (.). +65 è 'A' in ASCII, quindi alla fine viene stampata 'A'. + + +, [ > + < - ] > . + +Questo programma legge un carattere come input dall'utente, +quindi salva il carattere dentro la cella #1. +In seguito, incominca a ciclare. +Si sposta alla cella #², e increementa il valore della cella (#2). +Quindi torna alla cella #1, e decrementa il valore della cella (#1). +Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2 +avrà il valore iniziale della cella #1. +Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta +sulla cella #2 e stampa il valore in ASCII. + +Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere +una maggiore leggibilità, si poteva anche scrivere senza: + +,[>+<-]>. + +Proviamo, adesso, a capire cosa fa invece questo programma: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Prende due numeri in input e quindi li moltiplica. + +Prima prende in input i due numeri (,>,<), quindi inizia un cilclo +basandosi sulla cella #1. +Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato +dal valore della cella #2, incrementando la cella #3. +Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno +la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà +partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0. +Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella +#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 +nella cella #2, in modo che il ciclo interno +possa essere eseguito una altra volta. +Alla fine la cella #3 contiene il risultato. +``` + +E questo è brainfuck...Non è difficele, vero? +Per divertimento adesso puoi scrivere i tuoi programmi in brainfuck, +oppure puoi scrivere un interprete brainfuck in un altro linguaggio. +L'interprete è abbastanza semplice da implementare, ma se sei veramente +masochista prova ad implementare un interprete brainfuck in... +brainfuck. diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown new file mode 100644 index 00000000..e7e1d89e --- /dev/null +++ b/it-it/c++-it.html.markdown @@ -0,0 +1,720 @@ +--- +language: c++ +filename: learncpp-it.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it +--- + +Il C++ è un linguaggio di programmazione il quale, +[secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +è stato progettato per + +- essere un "miglior C" +- supportare l'astrazione dei dati +- supportare la programmazione orientata agli oggetti +- supportare la programmazione generica + +Nonostante la sintassi possa risultare più difficile o complessa di linguaggi più recenti, +è usato in maniera vasta poichè viene compilato in istruzioni macchina che possono +essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C) +ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi. +Questa combinazione di velocità e funzionalità rende il C++ +uno dei più utilizzati linguaggi di programmazione. + +```c++ +////////////////// +// Confronto con il C +////////////////// + +// Il C++ è _quasi_ un superset del C e con esso condivide la sintassi di base per +// la dichiarazione di variabili, tipi primitivi, e funzioni. + +// Proprio come nel C, l'inizio del programma è una funzione chiamata +// main con un intero come tipo di ritorno, +// Questo valore serve come stato d'uscita del programma. +// Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni. +int main(int argc, char** argv) +{ + // Gli argomenti a linea di comando sono passati tramite argc e argv così come + // avviene in C. + // argc indica il numero di argomenti, + // e argv è un array di stringhe in stile-C (char*) + // che rappresenta gli argomenti. + // Il primo argomento è il nome che è stato assegnato al programma. + // argc e argv possono essere omessi se non hai bisogno di argomenti, + // in questa maniera la funzione avrà int main() come firma. + + // Lo stato di uscita 0 indica successo. + return 0; +} + +// Tuttavia, il C++ varia nei seguenti modi: + +// In C++, i caratteri come letterali sono da un byte. +sizeof('c') == 1 + +// In C, i caratteri come letterali sono della stessa dimensione degli interi. +sizeof('c') == sizeof(10) + + +// C++ ha prototipizzazione rigida +void func(); // funziona che non accetta argomenti + +// In C +void func(); // funzione che può accettare un qualsiasi numero di argomenti + +// Usa nullptr invece di NULL in C++ +int* ip = nullptr; + +// Gli header C standard sono disponibili in C++, +// ma sono prefissati con "c" e non hanno il suffisso ".h". +#include <cstdio> + +int main() +{ + printf("Ciao, mondo!\n"); + return 0; +} + +/////////////////////////////// +// Overloading per le funzioni +////////////////////////////// + +// Il C++ supporta l'overloading per le funzioni +// sia dato che ogni funzione accetta parametri diversi. + +void print(char const* myString) +{ + printf("Stringa %s\n", myString); +} + +void print(int myInt) +{ + printf("Il mio int è %d", myInt); +} + +int main() +{ + print("Ciao"); // Viene chiamata void print(const char*) + print(15); // Viene chiamata void print(int) +} + +//////////////////////// +// Argomenti di default +/////////////////////// + +// Puoi fornire argomenti di default per una funzione +// se non sono forniti dal chiamante. + +void faiQualcosaConInteri(int a = 1, int b = 4) +{ + // fai qualcosa con gli interi qui +} + +int main() +{ + faiQualcosaConInteri(); // a = 1, b = 4 + faiQualcosaConInteri(20); // a = 20, b = 4 + faiQualcosaConInteri(20, 5); // a = 20, b = 5 +} + +// Gli argomenti di default devono essere alla fine della lista degli argomenti. + +void dichiarazioneInvalida(int a = 1, int b) // Errore! +{ +} + + +///////////// +// Namespaces +///////////// + +// I namespaces forniscono visibilità separata per dichiarazioni di variabili, funzioni, +// ed altro. +// I namespaces possono essere annidati. + +namespace Primo { + namespace Annidato { + void foo() + { + printf("Questa è Primo::Annidato::foo\n"); + } + } // fine di namespace Annidato +} // fine di namespace Primo + +namespace Secondo { + void foo() + { + printf("Questa è Secondo::foo\n") + } +} + +void foo() +{ + printf("Questa è foo globale\n"); +} + +int main() +{ + // Assume che tutto venga dal namespace "Secondo" + // a meno che non venga dichiarato altrimenti. + using namespace Secondo; + + foo(); // stampa "Questa è Secondo::foo" + Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo" + ::foo(); // stampa "Questa è foo globale" +} + +/////////////// +// Input/Output +/////////////// + +// L'input e l'output in C++ utilizza gli streams +// cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr. +// << è l'operatore di inserzione >> è l'operatore di estrazione. + +#include <iostream> // Include gli streams di I/O + +using namespace std; // Gli streams sono nel namespace std (libreria standard) + +int main() +{ + int myInt; + + // Stampa su stdout (o terminalee/schermo) + cout << "Inserisci il tuo numero preferito:\n"; + // Prende l'input + cin >> myInt; + + // cout può anche essere formattato + cout << "Il tuo numero preferito è " << myInt << "\n"; + // stampa "Il tuo numero preferito è <myInt>" + + cerr << "Usato per messaggi di errore"; +} + +//////////// +// Stringhe +/////////// + +// Le stringhe in C++ sono oggetti ed hanno molte funzioni membro +#include <string> + +using namespace std; // Anche le stringhe sono contenute nel namespace std (libreria standard) + +string myString = "Ciao"; +string myOtherString = " Mondo"; + +// + è usato per la concatenazione. +cout << myString + myOtherString; // "Ciao Mondo" + +cout << myString + " Bella"; // "Ciao Bella" + +// le stringhe in C++ possono essere modificate. +myString.append(" Mario"); +cout << myString; // "Ciao Mario" + + +/////////////// +// Riferimenti +////////////// + +// Oltre ai puntatori come quelli in C, +// il C++ ha i _riferimenti_. +// Questi non sono tipi puntatori che non possono essere riassegnati una volta settati +// e non possono essere null. +// Inoltre, essi hanno la stessa sintassi della variabile stessa: +// * non è necessario per la dereferenziazione e +// & ("indirizzo di") non è usato per l'assegnamento. + +using namespace std; + +string foo = "Io sono foo"; +string bar = "Io sono bar"; + + +string& fooRef = foo; // Questo crea un riferimento a foo. +fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento +cout << fooRef; // Stampa "Io sono foo. Ciao!" + +// Non riassegna "fooRef". Questo è come scrivere "foo = bar", e +// foo == "Io sono bar" +// dopo questa riga. +fooRef = bar; + +const string& barRef = bar; // Crea un riferimento const a bar. +// Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati. +barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati. + +////////////////////////////////////////////////// +// Classi e programmazione orientata agli oggetti +///////////////////////////////////////////////// + +// Primo esempio delle classi +#include <iostream> + +// Dichiara una classe. +// Le classi sono in genere dichiara in un header file (.h o .hpp). +class Cane { + // Variabili e funzioni membro sono private di default. + std::string nome; + int peso; + +// Tutti i membri dopo questo sono pubblici (public) +// finchè "private:" o "protected:" non compaiono. +public: + + // Costruttore di default + Cane(); + + // Dichiarazioni di funzioni membro (le implentazioni sono a seguito) + // Nota che stiamo usando std::string invece di porre + // using namespace std; + // sopra. + // Mai usare uno statement "using namespace" in uno header. + void impostaNome(const std::string& nomeCane); + + void impostaPeso(int pesoCane); + + // Le funzioni che non modificano lo stato dell'oggetto + // dovrebbero essere marcate come const. + // Questo permette di chiamarle con un riferimento const all'oggetto. + // Inoltre, nota che le funzioni devono essere dichiarate espliciamente come _virtual_ + // per essere sovrascritte in classi derivate. + // Le funzioni non sono virtual di default per motivi di performance. + virtual void print() const; + + // Le funzioni possono essere definite anche all'interno del corpo della classe. + // Le funzioni definite in questo modo sono automaticamente inline. + void abbaia() const { std::cout << nome << " abbaia!\n"; } + + // Assieme con i costruttori, il C++ fornisce i distruttori. + // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità. + // Questo permette paradigmi potenti come il RAII + // (vedi sotto) + // I distruttori devono essere virtual per permettere a classi di essere derivate da questa. + virtual ~Dog(); + +}; // Un punto e virgola deve seguire la definizione della funzione + +// Le funzioni membro di una classe sono generalmente implementate in files .cpp . +void Cane::Cane() +{ + std::cout << "Un cane è stato costruito\n"; +} + +// Gli oggetti (ad esempio le stringhe) devono essere passati per riferimento +// se li stai modificando o come riferimento const altrimenti. +void Cane::impostaNome(const std::string& nomeCane) +{ + nome = nomeCane; +} + +void Cane::impostaPeso(int pesoCane) +{ + peso = pesoCane; +} + +// Notare che "virtual" è solamente necessario nelle dichiarazioni, non nelle definizioni. +void Cane::print() const +{ + std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n"; +} + +void Cane::~Cane() +{ + cout << "Ciao ciao " << nome << "\n"; +} + +int main() { + Cane myDog; // stampa "Un cane è stato costruito" + myDog.impostaNome("Barkley"); + myDog.impostaPeso(10); + myDog.print(); // stampa "Il cane è Barkley e pesa 10 kg" + return 0; +} // stampa "Ciao ciao Barkley" + +// Ereditarietà: + +// Questa classe eredita tutto ciò che è public e protected dalla classe Cane +class MioCane : public Cane { + + void impostaProprietario(const std::string& proprietarioCane) + + // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi + // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29 + // per una introduzione più generale se non sei familiare con + // il polimorfismo. + // La parola chiave override è opzionale ma fa sì che tu stia effettivamente + // sovrascrivendo il metodo nella classe base. + void print() const override; + +private: + std::string proprietario; +}; + +// Nel frattempo, nel file .cpp corrispondente: + +void MioCane::impostaProprietario(const std::string& proprietarioCane) +{ + proprietario = proprietarioCane; +} + +void MioCane::print() const +{ + Cane::print(); // Chiama la funzione print nella classe base Cane + std::cout << "Il cane è di " << proprietario << "\n"; + // stampa "Il cane è <nome> e pesa <peso>" + // "Il cane è di <proprietario>" +} + +/////////////////////////////////////////////////// +// Inizializzazione ed Overloading degli Operatori +////////////////////////////////////////////////// + +// In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc... +// Questo è possibile definendo una funzione che viene chiamata +// ogniqualvolta l'operatore è usato. + +#include <iostream> +using namespace std; + +class Punto { +public: + // Così si assegna alle variabili membro un valore di default. + double x = 0; + double y = 0; + + // Definisce un costruttore di default che non fa nulla + // ma inizializza il Punto ai valori di default (0, 0) + Punto() { }; + + // La sintassi seguente è nota come lista di inizializzazione + // ed è il modo appropriato di inizializzare i valori membro della classe + Punto (double a, double b) : + x(a), + y(b) + { /* Non fa nulla eccetto inizializzare i valori */ } + + // Sovrascrivi l'operatore +. + Punto operator+(const Punto& rhs) const; + + // Sovrascrivi l'operatore += + Punto& operator+=(const Punto& rhs); + + // Avrebbe senso aggiungere gli operatori - e -=, + // ma li saltiamo per rendere la guida più breve. +}; + +Punto Punto::operator+(const Punto& rhs) const +{ + // Crea un nuovo punto come somma di questo e di rhs. + return Punto(x + rhs.x, y + rhs.y); +} + +Punto& Punto::operator+=(const Punto& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Punto su (0,1); + Punto destro (1,0); + // Questo chiama l'operatore + di Punto + // Il Punto su chiama la funzione + con destro come argomento + Punto risultato = su + destro; + // Stampa "Risultato è spostato in (1,1)" + cout << "Risultato è spostato (" << risultato.x << ',' << risultato.y << ")\n"; + return 0; +} + +///////////////// +// Templates +//////////////// + +// Generalmente i templates in C++ sono utilizzati per programmazione generica, anche se +// sono molto più potenti dei costrutti generici in altri linguaggi. Inoltre, +// supportano specializzazione esplicita e parziale, classi in stile funzionale, +// e sono anche complete per Turing. + +// Iniziamo con il tipo di programmazione generica con cui forse sei familiare. Per +// definire una classe o una funzione che prende un parametro di un dato tipo: +template<class T> +class Box { + // In questa classe, T può essere usato come qualsiasi tipo. + void inserisci(const T&) { ... } +}; + +// Durante la compilazione, il compilatore in effetti genera copie di ogni template +// con i parametri sostituiti, e così la definizione completa della classe deve essere +// presente ad ogni invocazione. Questo è il motivo per cui vedrai le classi template definite +// interamente in header files. + +// Per instanziare una classe template sullo stack: +Box<int> intBox; + +// e puoi usarla come aspettato: +intBox.inserisci(123); + +//Puoi, ovviamente, innestare i templates: +Box<Box<int> > boxOfBox; +boxOfBox.inserisci(intBox); + +// Fino al C++11, devi porre uno spazio tra le due '>', altrimenti '>>' +// viene visto come l'operatore di shift destro. + +// Qualche volta vedrai +// template<typename T> +// invece. La parole chiavi 'class' e 'typename' sono _generalmente_ +// intercambiabili in questo caso. Per una spiegazione completa, vedi +// http://en.wikipedia.org/wiki/Typename +// (si, quella parola chiave ha una sua pagina di Wikipedia propria). + +// Similmente, una funzione template: +template<class T> +void abbaiaTreVolte(const T& input) +{ + input.abbaia(); + input.abbaia(); + input.abbaia(); +} + +// Nota che niente è specificato relativamente al tipo di parametri. Il compilatore +// genererà e poi verificherà il tipo di ogni invocazione del template, così che +// la funzione di cui sopra funzione con ogni tipo 'T' che ha const 'abbaia' come metodo! + +Cane fluffy; +fluffy.impostaNome("Fluffy") +abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia" tre volte. + +// I parametri template non devono essere classi: +template<int Y> +void stampaMessaggio() { + cout << "Impara il C++ in " << Y << " minuti!" << endl; +} + +// E poi esplicitamente specializzare i template per avere codice più efficiente. Ovviamente, +// la maggior parte delle casistiche reali non sono così triviali. +// Notare che avrai comunque bisogna di dichiarare la funzione (o classe) come un template +// anche se hai esplicitamente specificato tutti i parametri. +template<> +void stampaMessaggio<10>() { + cout << "Impara il C++ più velocemente in soli 10 minuti!" << endl; +} + +printMessage<20>(); // Stampa "impara il C++ in 20 minuti!" +printMessage<10>(); // Stampa "Impara il C++ più velocemente in soli 10 minuti!" + +//////////////////////////// +// Gestione delle eccezioni +/////////////////////////// + +// La libreria standard fornisce un paio di tipi d'eccezioni +// (vedi http://en.cppreference.com/w/cpp/error/exception) +// ma ogni tipo può essere lanciato come eccezione +#include <exception> + +// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi +// handlers _catch_. +try { + // Non allocare eccezioni nello heap usando _new_. + throw std::exception("È avvenuto un problema"); +} +// Cattura le eccezioni come riferimenti const se sono oggetti +catch (const std::exception& ex) +{ + std::cout << ex.what(); +// Cattura ogni eccezioni non catturata dal blocco _catch_ precedente +} catch (...) +{ + std::cout << "Catturata un'eccezione sconosciuta"; + throw; // Rilancia l'eccezione +} + +/////// +// RAII +/////// + +// RAII sta per Resource Allocation Is Initialization. +// Spesso viene considerato come il più potente paradigma in C++. +// È un concetto semplice: un costruttore di un oggetto +// acquisisce le risorse di tale oggetto ed il distruttore le rilascia. + +// Per comprendere come questo sia vantaggioso, +// consideriamo una funzione che usa un gestore di file in C: +void faiQualcosaConUnFile(const char* nomefile) +{ + // Per cominciare, assumiamo che niente possa fallire. + + FILE* fh = fopen(nomefile, "r"); // Apri il file in modalità lettura. + + faiQualcosaConIlFile(fh); + faiQualcosAltroConEsso(fh); + + fclose(fh); // Chiudi il gestore di file. +} + +// Sfortunatamente, le cose vengono complicate dalla gestione degli errori. +// Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e +// faiQualcosAltroConEsso ritornano codici d'errore se falliscono. +// (Le eccezioni sono la maniera preferita per gestire i fallimenti, +// ma alcuni programmatori, specialmente quelli con un passato in C, +// non sono d'accordo con l'utilità delle eccezioni). +// Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file +// se un problema è avvenuto. +bool faiQualcosaConUnFile(const char* nomefile) +{ + FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura + if (fh == nullptr) // Il puntatore restituito è null in caso di fallimento. + return false; // Riporta il fallimento al chiamante. + + // Assumiamo che ogni funzione ritorni false se ha fallito + if (!faiQualcosaConIlFile(fh)) { + fclose(fh); // Chiude il gestore di file così che non sprechi memoria. + return false; // Propaga l'errore. + } + if (!faiQualcosAltroConEsso(fh)) { + fclose(fh); // Chiude il gestore di file così che non sprechi memoria. + return false; // Propaga l'errore. + } + + fclose(fh); // Chiudi il gestore di file così che non sprechi memoria. + return true; // Indica successo +} + +// I programmatori C in genere puliscono questa procedura usando goto: +bool faiQualcosaConUnFile(const char* nomefile) +{ + FILE* fh = fopen(nomefile, "r"); + if (fh == nullptr) + return false; + + if (!faiQualcosaConIlFile(fh)) + goto fallimento; + + if (!faiQualcosAltroConEsso(fh)) + goto fallimento; + + fclose(fh); // Chiude il file + return true; // Indica successo + +fallimento: + fclose(fh); + return false; // Propaga l'errore +} + +// Se le funzioni indicano errori usando le eccezioni, +// le cose sono un pò più pulite, ma sono sempre sub-ottimali. +void faiQualcosaConUnFile(const char* nomefile) +{ + FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura + if (fh == nullptr) + throw std::exception("Non è stato possibile aprire il file."). + + try { + faiQualcosaConIlFile(fh); + faiQualcosAltroConEsso(fh); + } + catch (...) { + fclose(fh); // Fai sì che il file venga chiuso se si ha un errore. + throw; // Poi rilancia l'eccezione. + } + + fclose(fh); // Chiudi il file + // Tutto è andato bene +} + +// Confronta questo con l'utilizzo della classe C++ file stream (fstream) +// fstream usa i distruttori per chiudere il file. +// Come detto sopra, i distruttori sono automaticamente chiamati +// ogniqualvolta un oggetto esce dalla visibilità. +void faiQualcosaConUnFile(const std::string& nomefile) +{ + // ifstream è l'abbreviazione di input file stream + std::ifstream fh(nomefile); // Apre il file + + // Fai qualcosa con il file + faiQualcosaConIlFile(fh); + faiQualcosAltroConEsso(fh); + +} // Il file viene chiuso automaticamente chiuso qui dal distruttore + +// Questo ha vantaggi _enormi_: +// 1. Può succedere di tutto ma +// la risorsa (in questo caso il file handler) verrà ripulito. +// Una volta che scrivi il distruttore correttamente, +// È _impossibile_ scordarsi di chiudere l'handler e sprecare memoria. +// 2. Nota che il codice è molto più pulito. +// Il distruttore gestisce la chiusura del file dietro le scene +// senza che tu debba preoccupartene. +// 3. Il codice è sicuro da eccezioni. +// Una eccezione può essere lanciata in qualunque punto nella funzione e la ripulitura +// avverrà lo stesso. + +// Tutto il codice C++ idiomatico usa RAII in maniera vasta su tutte le risorse. +// Esempi aggiuntivi includono +// - Utilizzo della memoria con unique_ptr e shared_ptr +// - I contenitori - la lista della libreria standard, +// vettori (i.e. array auto-aggiustati), mappe hash, e così via +// sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità. +// - I mutex usano lock_guard e unique_lock + +/////////////////////// +// Roba divertente +////////////////////// + +// Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano). +// Questa sezione è, sfortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi +// più facili con cui puoi spararti da solo nel piede. + +// Puoi sovrascrivere metodi privati! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // sovrascrive Foo::bar! +}; + + +// 0 == false == NULL (la maggior parte delle volte)! +bool* pt = new bool; +*pt = 0; // Setta il valore puntato da 'pt' come falso. +pt = 0; // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings. + +// nullptr dovrebbe risolvere alcune di quei problemi: +int* pt2 = new int; +*pt2 = nullptr; // Non compila +pt2 = nullptr; // Setta pt2 a null. + +// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`. +*pt = nullptr; // Questo compila, anche se '*pt' è un bool! + + +// '=' != '=' != '='! +// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia. +Foo f2; +Foo f1 = f2; + +// Chiama Foo::Foo(const Foo&) o qualche variante, ma solo copie di 'Foo' che fanno parte di +// 'fooSub'. Ogni altro membro di 'fooSub' viene scartato. Questo comportamento +// orribile viene chiamato "object slicing." +FooSub fooSub; +Foo f1 = fooSub; + +// Chiama Foo::operator=(Foo&) o una sua variante. +Foo f1; +f1 = f2; + +``` +Letture consigliate: + +Un riferimento aggiornato del linguaggio può essere trovato qui +<http://cppreference.com/w/cpp> + +Risorse addizionali possono essere trovate qui <http://cplusplus.com> diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown new file mode 100644 index 00000000..16eb9bd4 --- /dev/null +++ b/it-it/coffeescript-it.html.markdown @@ -0,0 +1,107 @@ +--- +language: coffeescript +contributors: + - ["Luca 'Kino' Maroni", "http://github.com/kino90"] + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +filename: coffeescript-it.coffee +lang: it-it +--- + +CoffeeScript è un piccolo linguaggio che compila direttamente nell'equivalente +JavaScript, non c'è nessuna interpretazione a runtime. Come possibile +successore di Javascript, CoffeeScript fa il suo meglio per restituire +un codice leggibile, ben stampato e performante in ogni ambiente JavaScript. + +Guarda anche [il sito di CoffeeScript](http://coffeescript.org/), che ha una +guida completa a CoffeeScript. + +```coffeescript +# CoffeeScript è un linguaggio hipster. +# Segue le mode di alcuni linguaggi moderni. +# Quindi i commenti sono come quelli di Ruby e Python, usano il cancelletto. + +### +I blocchi di commenti sono definiti con tre cancelletti, che vengono tradotti +direttamente in `/*` e `*/` nel codice JavaScript risultante. + +Prima di continuare devi conoscere la maggior parte +delle semantiche JavaScript. +### + +# Assegnamento: +numero = 42 #=> var numero = 42; +contrario = true #=> var contrario = true; + +# Condizioni: +numero = -42 if contrario #=> if(contrario) { numero = -42; } + +# Funzioni: +quadrato = (x) -> x * x #=> var quadrato = function(x) { return x * x; } + +riempi = (contenitore, liquido = "caffè") -> + "Sto riempiendo #{contenitore} con #{liquido}..." +#=>var riempi; +# +#riempi = function(contenitore, liquido) { +# if (liquido == null) { +# liquido = "caffè"; +# } +# return "Sto riempiendo " + contenitore + " con " + liquido + "..."; +#}; + +# Intervalli: +lista = [1..5] #=> var lista = [1, 2, 3, 4, 5]; + +# Oggetti: +matematica = + radice: Math.sqrt + quadrato: quadrato + cubo: (x) -> x * quadrato x +#=> var matematica = { +# "radice": Math.sqrt, +# "quadrato": quadrato, +# "cubo": function(x) { return x * quadrato(x); } +#} + +# Splats: +gara = (vincitore, partecipanti...) -> + print vincitore, partecipanti +#=>gara = function() { +# var partecipanti, vincitore; +# vincitore = arguments[0], partecipanti = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(vincitore, partecipanti); +#}; + +# Esistenza: +alert "Lo sapevo!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Lo sapevo!"); } + +# Comprensione degli Array: +cubi = (matematica.cubo num for num in lista) +#=>cubi = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = lista.length; _i < _len; _i++) { +# num = lista[_i]; +# _results.push(matematica.cubo(num)); +# } +# return _results; +# })(); + +cibi = ['broccoli', 'spinaci', 'cioccolato'] +mangia cibo for cibo in cibi when cibo isnt 'cioccolato' +#=>cibi = ['broccoli', 'spinaci', 'cioccolato']; +# +#for (_k = 0, _len2 = cibi.length; _k < _len2; _k++) { +# cibo = cibi[_k]; +# if (cibo !== 'cioccolato') { +# mangia(cibo); +# } +#} +``` + +## Altre risorse + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown new file mode 100644 index 00000000..f5d0c172 --- /dev/null +++ b/it-it/elixir-it.html.markdown @@ -0,0 +1,418 @@ +--- +language: elixir +contributors: + - ["Luca 'Kino' Maroni", "https://github.com/kino90"] + - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] +filename: learnelixir-it.ex +lang: it-it +--- + +Elixir è un linguaggio funzionale moderno, costruito sulla VM Erlang. +È totalmente compatibile con Erlang, ma con una sintassi più standard +e molte altre funzionalità. + +```elixir + +# I commenti su una riga iniziano con un cancelletto. + +# Non esistono commenti multilinea, +# ma puoi concatenare più commenti. + +# Per usare la shell di elixir usa il comando `iex`. +# Compila i tuoi moduli con il comando `elixirc`. + +# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato +# elixir correttamente. + +## --------------------------- +## -- Tipi di base +## --------------------------- + +# Numeri +3 # intero (Integer) +0x1F # intero +3.0 # decimale (Float) + +# Atomi, che sono literals, una costante con un nome. Iniziano con `:`. +:ciao # atomo (Atom) + +# Tuple che sono salvate in celle di memoria contigue. +{1,2,3} # tupla (Tuple) + +# Possiamo accedere ad un elemento di una tupla con la funzione `elem`: +elem({1, 2, 3}, 0) #=> 1 + +# Liste, che sono implementate come liste concatenate (o linked list). +[1,2,3] # lista (List) + +# Possiamo accedere alla testa (head) e alla coda (tail) delle liste così: +[testa | coda] = [1,2,3] +testa #=> 1 +coda #=> [2,3] + +# In Elixir, proprio come in Erlang, il simbolo `=` denota pattern matching e +# non un assegnamento. +# +# Questo significa che la parte sinistra (pattern) viene confrontata alla +# parte destra. +# +# Questo spiega il funzionamento dell'esempio dell'accesso alla lista di prima. + +# Un pattern match darà errore quando le parti non combaciano, ad esempio se +# le tuple hanno dimensione differente. +# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} + +# Ci sono anche i binari +<<1,2,3>> # binari (Binary) + +# Stringhe e liste di caratteri +"ciao" # stringa (String) +'ciao' # lista di caratteri (List) + +# Stringhe multilinea +""" +Sono una stringa +multi-linea. +""" +#=> "Sono una stringa\nmulti-linea.\n" + +# Le stringhe sono tutte codificate in UTF-8: +"cìaò" +#=> "cìaò" + +# le stringhe in realtà sono dei binari, e le liste di caratteri sono liste. +<<?a, ?b, ?c>> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# `?a` in elixir restituisce il valore ASCII della lettera `a` +?a #=> 97 + +# Per concatenare liste si usa `++`, per binari si usa `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'ciao ' ++ 'mondo' #=> 'ciao mondo' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"ciao " <> "mondo" #=> "ciao mondo" + +# Gli intervalli sono rappresentati come `inizio..fine` (estremi inclusi) +1..10 #=> 1..10 (Range) +minore..maggiore = 1..10 # Puoi fare pattern matching anche sugli intervalli +[minore, maggiore] #=> [1, 10] + +## --------------------------- +## -- Operatori +## --------------------------- + +# Un po' di matematica +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# In elixir l'operatore `/` restituisce sempre un decimale. + +# Per fare una divisione intera si usa `div` +div(10, 2) #=> 5 + +# Per ottenere il resto di una divisione si usa `rem` +rem(10, 3) #=> 1 + +# Ci sono anche gli operatori booleani: `or`, `and` e `not`. +# Questi operatori si aspettano un booleano come primo argomento. +true and true #=> true +false or true #=> true +# 1 and true #=> ** (ArgumentError) argument error + +# Elixir fornisce anche `||`, `&&` e `!` che accettano argomenti +# di qualsiasi tipo. +# Tutti i valori tranne `false` e `nil` saranno valutati come true. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil +!true #=> false + +# Per i confronti abbiamo: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` e `!==` sono più rigidi quando si confrontano interi e decimali: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# Possiamo anche confrontare tipi di dato diversi: +1 < :ciao #=> true + +# L'ordine generale è definito sotto: +# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste +# < stringhe di bit + +# Per citare Joe Armstrong su questo: "L'ordine non è importante, +# ma è importante che sia definito un ordine." + +## --------------------------- +## -- Controllo di flusso +## --------------------------- + +# espressione `se` (`if`) +if false do + "Questo non si vedrà mai" +else + "Questo sì" +end + +# c'è anche un `se non` (`unless`) +unless true do + "Questo non si vedrà mai" +else + "Questo sì" +end + +# Ti ricordi il pattern matching? +# Moltre strutture di controllo di flusso in elixir si basano su di esso. + +# `case` ci permette di confrontare un valore a diversi pattern: +case {:uno, :due} do + {:quattro, :cinque} -> + "Questo non farà match" + {:uno, x} -> + "Questo farà match e binderà `x` a `:due`" + _ -> + "Questo farà match con qualsiasi valore" +end + +# Solitamente si usa `_` se non si ha bisogno di utilizzare un valore. +# Ad esempio, se ci serve solo la testa di una lista: +[testa | _] = [1,2,3] +testa #=> 1 + +# Per aumentare la leggibilità possiamo usarlo in questo modo: +[testa | _coda] = [:a, :b, :c] +testa #=> :a + +# `cond` ci permette di verificare più condizioni allo stesso momento. +# Usa `cond` invece di innestare più espressioni `if`. +cond do + 1 + 1 == 3 -> + "Questa stringa non si vedrà mai" + 2 * 5 == 12 -> + "Nemmeno questa" + 1 + 2 == 3 -> + "Questa sì!" +end + +# È pratica comune mettere l'ultima condizione a `true`, che farà sempre match +cond do + 1 + 1 == 3 -> + "Questa stringa non si vedrà mai" + 2 * 5 == 12 -> + "Nemmeno questa" + true -> + "Questa sì! (essenzialmente funziona come un else)" +end + +# `try/catch` si usa per gestire i valori lanciati (throw), +# Supporta anche una clausola `after` che è invocata in ogni caso. +try do + throw(:ciao) +catch + message -> "Ho ricevuto #{message}." +after + IO.puts("Io sono la clausola 'after'.") +end +#=> Io sono la clausola 'after' +# "Ho ricevuto :ciao" + +## --------------------------- +## -- Moduli e Funzioni +## --------------------------- + +# Funzioni anonime (notare il punto) +quadrato = fn(x) -> x * x end +quadrato.(5) #=> 25 + +# Accettano anche guardie e condizioni multiple. +# le guardie ti permettono di perfezionare il tuo pattern matching, +# sono indicate dalla parola chiave `when`: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir fornisce anche molte funzioni, disponibili nello scope corrente. +is_number(10) #=> true +is_list("ciao") #=> false +elem({1,2,3}, 0) #=> 1 + +# Puoi raggruppare delle funzioni all'interno di un modulo. +# All'interno di un modulo usa `def` per definire le tue funzioni. +defmodule Matematica do + def somma(a, b) do + a + b + end + + def quadrato(x) do + x * x + end +end + +Matematica.somma(1, 2) #=> 3 +Matematica.quadrato(3) #=> 9 + +# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa +# `elixirc`. +# nel tuo terminale: elixirc matematica.ex + +# All'interno di un modulo possiamo definire le funzioni con `def` e funzioni +# private con `defp`. +# Una funzione definita con `def` è disponibile per essere invocata anche da +# altri moduli, una funziona privata può essere invocata solo localmente. +defmodule MatematicaPrivata do + def somma(a, b) do + esegui_somma(a, b) + end + + defp esegui_somma(a, b) do + a + b + end +end + +MatematicaPrivata.somma(1, 2) #=> 3 +# MatematicaPrivata.esegui_somma(1, 2) #=> ** (UndefinedFunctionError) + +# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple: +defmodule Geometria do + def area({:rettangolo, w, h}) do + w * h + end + + def area({:cerchio, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometria.area({:rettangolo, 2, 3}) #=> 6 +Geometria.area({:cerchio, 3}) #=> 28.25999999999999801048 +# Geometria.area({:cerchio, "non_un_numero"}) +#=> ** (FunctionClauseError) no function clause matching in Geometria.area/1 + +# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in elixir +defmodule Ricorsione do + def somma_lista([testa | coda], accumulatore) do + somma_lista(coda, accumulatore + testa) + end + + def somma_lista([], accumulatore) do + accumulatore + end +end + +Ricorsione.somma_lista([1,2,3], 0) #=> 6 + +# I moduli di Elixir supportano attributi. Ci sono degli attributi incorporati +# e puoi anche aggiungerne di personalizzati. +defmodule Modulo do + @moduledoc """ + Questo è un attributo incorporato in un modulo di esempio. + """ + + @miei_dati 100 # Questo è un attributo personalizzato . + IO.inspect(@miei_dati) #=> 100 +end + +## --------------------------- +## -- Strutture ed Eccezioni +## --------------------------- + + +# Le Strutture (Structs) sono estensioni alle mappe che portano +# valori di default, garanzia alla compilazione e polimorfismo in Elixir. +defmodule Persona do + defstruct nome: nil, eta: 0, altezza: 0 +end + +luca = %Persona{ nome: "Luca", eta: 24, altezza: 185 } +#=> %Persona{eta: 24, altezza: 185, nome: "Luca"} + +# Legge al valore di 'nome' +luca.nome #=> "Luca" + +# Modifica il valore di eta +luca_invecchiato = %{ luca | eta: 25 } +#=> %Persona{eta: 25, altezza: 185, nome: "Luca"} + +# Il blocco `try` con la parola chiave `rescue` è usato per gestire le eccezioni +try do + raise "un errore" +rescue + RuntimeError -> "Salvato un errore di Runtime" + _error -> "Questo salverà da qualsiasi errore" +end + +# Tutte le eccezioni hanno un messaggio +try do + raise "un errore" +rescue + x in [RuntimeError] -> + x.message +end + +## --------------------------- +## -- Concorrenza +## --------------------------- + +# Elixir si basa sul modello degli attori per la concorrenza. +# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir +# sono tre primitive: creare processi, inviare messaggi e ricevere messaggi. + +# Per creare un nuovo processo si usa la funzione `spawn`, che riceve una +# funzione come argomento. +f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> +spawn(f) #=> #PID<0.40.0> + +# `spawn` restituisce un pid (identificatore di processo). Puoi usare questo +# pid per inviare messaggi al processo. +# Per passare messaggi si usa l'operatore `send`. +# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi, +# oltre ad inviarli. Questo è realizzabile con `receive`: +defmodule Geometria do + def calcolo_area do + receive do + {:rettangolo, w, h} -> + IO.puts("Area = #{w * h}") + calcolo_area() + {:cerchio, r} -> + IO.puts("Area = #{3.14 * r * r}") + calcolo_area() + end + end +end + +# Compila il modulo e crea un processo che esegue `calcolo_area` nella shell +pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0> + +# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive +send pid, {:rettangolo, 2, 3} +#=> Area = 6 +# {:rettangolo,2,3} + +send pid, {:cerchio, 2} +#=> Area = 12.56000000000000049738 +# {:cerchio,2} + +# Anche la shell è un processo. Puoi usare `self` per ottenere il pid corrente +self() #=> #PID<0.27.0> +``` + +## Referenze + +* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org) +* [Documentazione Elixir](http://elixir-lang.org/docs/master/) +* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas +* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) di Fred Hebert +* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) di Joe Armstrong diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown new file mode 100644 index 00000000..6eabd61f --- /dev/null +++ b/it-it/java-it.html.markdown @@ -0,0 +1,502 @@ +--- +language: java +filename: LearnJava-it.java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Madison Dickson", "http://github.com/mix3d"] +translators: + - ["Ivan Sala","http://github.com/slavni96"] +lang: it-it +--- + +Java è un linguaggio di programmazione orientato ad oggetti, +concorrente, basato su classi e adatto a svariati scopi. +[Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// I commenti su singola linea incominciano con // +/* +I commenti su piu' linee invece sono cosi' +*/ +/** +I commenti per la documentazione JavaDoc si fanno cosi'. +Vengono usati per descrivere una classe o alcuni suoi attributi. +*/ + +// Per importare la classe ArrayList conenuta nel package java.util +import java.util.ArrayList; +// Per importare tutte le classi contenute nel package java.security +import java.security.*; + +// Ogni file .java contiene una classe pubblica, con lo stesso nome del file +public class LearnJava { + + // Un programma deve avere un metodo main come punto di partenza + // Ma si possono creare anche file senza main, che però per essere usati + // devono essere richiamati da altri file. + public static void main (String[] args) { + + // Per stampare a schermo si usa System.out.println + System.out.println("Ciao Mondo!"); + System.out.println( + "Intero [integer]: " + 10 + + " Reale [double]: " + 3.14 + + " Booleano [boolean]: " + true); + + // Se non si vuole andare a capo, si puo' usare System.out.print + System.out.print("Ciao "); + System.out.print("Mondo "); + + + /////////////////////////////////////// + // Tipi e Variabili + /////////////////////////////////////// + // Si dichiara una variabile usando <tipo> <nome> + // Byte - variabile intera da 8 bit con segno + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - variabile intera da 18 bit con segno + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - variabile intera da 32 bit con segno + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - variabile da 64 bit intera con segno + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L viene usato per specificare che il valore dalla variabile + // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata + // e' trattata di base come un intero. + + // Nota: Java non dispone di variabili senza segno + + // Float - variabile piu' precisa, con virgola [numeri reali] + // di grandezza 32 bit + float fooFloat = 234.5f; + // f e' usato per specificare che la variabile e'' di tipo "float" + // altrimenti di default viene trattata come un "dobule" + + // Double - ancora piu' precisione la si puo' ottenere con una variabile + // Double, con granzezza di 64 bit. + double fooDouble = 123.4; + + // Boolean - vero & falso + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - un singolo carattere con grandezza 16 bit + char fooChar = 'A'; + + // final - Costanti, non possono essere riassegnate ad un altro oggetto + final int ORE_LAVORATIVE_DI_UNA_SETTIMANA = 9001; + + // String - Stringhe, array di caratteri + String fooString = "Ecco una stringa!"; + + // \n e' un carattere speciale che permette di andare a capo. + String barString = "Andare a capo?\nNessun problema!"; + // \t e' un carattere speciale che permette di aggiungere un 'Tab' + String bazString = "Vuoi inserire tab?\tNessun problema"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // Vettori [array] + //La lunghezza del vettore deve essere decisa quando viene istanziato + //Si puo' dichiarare come segue: + //<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>]; + //<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>]; + int [] intArray = new int[10]; + String [] stringArray = new String[1]; + boolean boolArray [] = new boolean[100]; + + // Un altro modo per dichiarare & inizializzare un vettore + int [] y = {9000, 1000, 1337}; + String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; + boolean bools[] = new boolean[] {true, false, false}; + + // I vettori vengono indicizzati a parire dallo 0 + System.out.println("intArray @ 0: " + intArray[0]); + + // e' possibile un accesso diretto ad un elemento + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // Altro da vedere: + // Liste di array - come i vettori ma piu' funzionali + // e la loro grandezza puo' variare in corso di esecuzione + // Liste concatenate di memoria + + /////////////////////////////////////// + // Operatori + /////////////////////////////////////// + System.out.println("\n->Operatori"); + + int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea + + // L'aritmetica e' lineare. + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 + // (con 0.5 arrotonda per difetto) + + // Modulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Operatori di confronto + System.out.println("3 == 2? " + (3 == 2)); // => falso + System.out.println("3 != 2? " + (3 != 2)); // => vero + System.out.println("3 > 2? " + (3 > 2)); // => vero + System.out.println("3 < 2? " + (3 < 2)); // => falso + System.out.println("2 <= 2? " + (2 <= 2)); // => vero + System.out.println("2 >= 2? " + (2 >= 2)); // => vero + + // Operatori binari orientati ai bit + // effettuano le operazioni logiche confrontando, i bit degli operandi: + /* + ~ complemento + << shift sinistro con segno + >> shift destro con segno + >>> shift destro senza segno + & AND Binario Bitwise AND + ^ OR Esclusivo + | OR Incusivo + */ + + // Incrementare e Decrementare + int i = 0; + System.out.println("\n->Incrementare/Decrementare"); + // Gli operatori ++ e -- incrementano e decrementano rispettivamente di 1. + // Se posizionati prima della variabile, incrementano, quindi riportano. + // Se si trovano dopo la variabile, riporano, e quindi incrementano. + System.out.println(i++); //i = 1, Stampa 0 (post-incremento) + System.out.println(++i); //i = 2, Stampa 2 (pre-incremento) + System.out.println(i--); //i = 1, Stampa 2 (post-decremento) + System.out.println(--i); //i = 0, Stampa 0 (pre-decremento) + + /////////////////////////////////////// + // Strutture di controllo + /////////////////////////////////////// + System.out.println("\n->Strutture di controllo"); + + // La dichiarazione dell'If e'' C-like. + int j = 10; + if (j == 10){ + System.out.println("Io vengo stampato"); + } else if (j > 10) { + System.out.println("Io no"); + } else { + System.out.println("E io neppure"); + } + + // Struttura While + int fooWhile = 0; + while(fooWhile < 100) + { + //System.out.println(fooWhile); + //Incrementa il contatore + //Si ripete per 100 volte, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("Valore di fooWhile: " + fooWhile); + + // Struttura Do While + int fooDoWhile = 0; + do + { + //System.out.println(fooDoWhile); + //Incrementa il contaore + //Si repete per 99 volte, fooDoWhile 0->99 + fooDoWhile++; + }while(fooDoWhile < 100); + System.out.println("Valore di fooWhile: " + fooDoWhile); + + // Struttura For + int fooFor; + //Struttura For => for(<Situazione iniziale>; <Condizione>; <passo>) + for(fooFor=0; fooFor<10; fooFor++){ + //System.out.println(fooFor); + //Itera 10 volte, fooFor 0->9 + } + System.out.println("Valore di fooFor: " + fooFor); + + // Struttura For Each + // Una iterazione automatica attraverso un array o una lista di oggetti + int[] fooList = {1,2,3,4,5,6,7,8,9}; + //struttura for each => for(<oggetto> : <oggetto dell'attay>) + //si legge: per ogni oggetto dell'array fai... + //Nota: il tipo dell'oggetto deve essere uguale a quello dell'array + + for( int bar : fooList ){ + //System.out.println(bar); + //Itera 9 volte e stampa 1-9 andando a capo. + } + + // Struttura Switch Case + // La struttura switch lavora con byte, short, char e int. + // Se funziona con i char funzionera ovviamente anche con le stringhe. + int mese = 3; + String stringaMese; + switch (mese){ + case 1: + stringaMese = "Genneio"; + break; + case 2: + stringaMese = "Febbraio"; + break; + case 3: + stringaMese = "Marzo"; + break; + default: + stringaMese = "Altri mesi"; + break; + } + System.out.println("Risultato del costrutto switch: " + stringaMese); + + // Condizioni brevi + // Si puo' usare l'operatore '?' per un rapido assegnamento + // o per operazioni logiche. + // Si legge: + // Se (condizione) e' vera, usa <primo valore>, altrimenti usa <secondo valore> + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println("Se la condizione e' vera stampa A: "+bar); + // Stampa A, perche' la condizione e' vera. + + + ///////////////////////////////////////// + // Convertire i tipi di tati e Typcasting + ///////////////////////////////////////// + + // Convertire tipi di dati + + // Stringhe ad interi + Integer.parseInt("123");//Riporta una versione intera di "123" + + // Interi a Stringhe + Integer.toString(123);//Riporta la stringa "123" + // Per altre conversioni guarda le seguenti classi + // Double + // Long + // String + + // Typecasting + // Vi sono molti dettagli che non si possono spiegare qui, + // java dispone di una ottima documentazione + // Sentiti libero di leggerla + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classi e funzioni + /////////////////////////////////////// + + System.out.println("\n->Classi & Funzioni"); + + // (Di seguito la definizione della classe Bicicletta) + + // Instanziare una nuova classe + Bicicletta percorso = new Bicicletta(); + + // Chiamare metodi + percorso.accellera(3); // Si usano sempre metodi set... get... + percorso.setCadenza(100); + + // toString riporta la rappresenzazione dell'oggetto + // come se fosse una stringa + System.out.println("percorso info: " + percorso.toString()); + + } // Fine metodo main +} // Fine classe LearnJava + + +// Si possono inculdere altre anche delle classi non pubbliche (private) +// oltre a quella pubblica principale, in un file .java + +// Sintassi per dichiarare una classe: +// <public/private/protected> class <Nome classe>{ +// //dati, variabili, costruttori, funzioni, tutto qua. +// //le funzioni sono chiamate come i metodi. +// } + +class Bicicletta { + + // Variabili della bicicletta + public int cadenza; + // Public: Puo' essere richiamato da qualsiasi classe + private int velocita; + // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato + protected int ingranaggi; + // Protected: e'' visto sia dalla classe che dalle sottoclassi + String nome; + // default: e'' accessibile sono all'interno dello stesso package + + // I costruttori vengono usati per creare variabili + // Questo e'' un costruttore + public Bicicletta() { + ingranaggi = 1; + cadenza = 50; + velocita = 5; + nome = "Bontrager"; + } + + // Questo e'' un costruttore che richiede parametri + public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) { + this.ingranaggi = ingranaggi; + this.cadenza = cadenza; + this.velocita = velocita; + this.nome = nome; + } + + // Sintassi delle funzioni: + // <public/private/protected> <tipo di ritorino> <nome della funzione>(<parametri>) + + // Le classi in java spesso implementano delle funzioni o metodo + // 'get...' o 'set...' + + // Dichiarazione di un metodo + // <scope> <tipo di ritorno> <nome del metodo>(<parametri>) + public int getCandenza() { + return cadenza; + } + + // i medodi (void) non necessitano di riportare un valore + public void setCadenza(int nuovoValore) { + cadenza = nuovoValore; + } + + public void setIngranaggi(int nuovoValore) { + ingranaggi = nuovoValore; + } + + public void accellera(int incrementa) { + velocita += incrementa; + } + + public void decellera(int decrementa) { + velocita -= decrementa; + } + + public void setNome(String nuovoNome) { + nome = nuovoNome; + } + + public String getNome() { + return nome; + } + + //Medoto per visualizzare gli attributi dell'oggetto + @Override + public String toString() { + return "Ingranaggi: " + ingranaggi + + " Cadenza: " + cadenza + + " Velocita: " + velocita + + " Nome: " + nome; + } +} // Fine classe bicicletta + +// PennyFarthing e'' una sottoclasse della bicicletta +class PennyFarthing extends Bicicletta { + // (Sono quelle biciclette con un unica ruota enorme + // Non hanno ingranaggi.) + + public PennyFarthing(int cadenzaIniziale, int velocitaIniziale){ + // Richiamo il costruttore del padre con super + super(cadenzaIniziale, velocitaIniziale, 0, "PennyFarthing"); + } + + // Bisogna contrassegnre un medodo che si sta riscrivendo + // con una @annotazione + // Per saperne di piu' sulle annotazioni + // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setIngranaggi(int ingranaggi) { + ingranaggi = 0; + } + +} +/* +//Interfacce +//Sintassi per dichiarare una interfaccia +//<livello di accesso> interface <nome dell'interfaccia> extends <super-interfaccia> { +// //Costanti +// //Dichiarazioni dei metodi +//} + +//Esempi- Cibo: +interface Commestibile { + public void mangia(); + //Ogni classe che implementa questa interfaccia + //deve implementare questo metodo. + } +interface Digeribile { + public void digerisci(); +} + +//Possiamo quindi creare una classe che implementa entrambe le interfaccie +class Frutta implements Commestibile, Digestibile { + public void mangia() { + //... + } + + public void digerisci() { + //... + } +} + +//In Java si puo' estendere solo una classe, ma si possono implementare +//piu' interfaccie, per esempio: +class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia { + public void MetodoPrimaInterfaccia() { + + } + + public void MetodoSecondaInterfaccia() { + + } +} +*/ +``` +## Letture future + +I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici + + +**Guida ufficiale di Oracle [solo in inglese]**: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) + + +**Tutorial Online [in inglese]** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Libri [in italiano]** : + +* [Java la guida completa](http://www.amazon.it/Java-guida-completa-Herbert-Schildt/dp/8838667667/ref=sr_1_1?ie=UTF8&qid=1393422296&sr=8-1&keywords=java) + +* [Thinking in java](http://www.amazon.it/Thinking-Java-1-Bruce-Eckel/dp/8871923030/ref=sr_1_8?ie=UTF8&qid=1393422296&sr=8-8&keywords=java) + +* [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300) diff --git a/it-it/json-it.html.markdown b/it-it/json-it.html.markdown new file mode 100644 index 00000000..0c401753 --- /dev/null +++ b/it-it/json-it.html.markdown @@ -0,0 +1,62 @@ +--- + +language: json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it + +--- + +Dato che JSON è un formato per lo scambio di dati estremamente semplice, questo sarà con molta probabilità +il più semplice Learn X in Y Minutes. + +Nella sua forma più pura JSON non ha commenti, ma molti parser accettano +commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sarà +100% JSON valido. Fortunatamente, si spiega da sè. + +```json +{ + "chiave": "valore", + + "chiavi": "devono sempre essere racchiuse tra doppi apici", + "numeri": 0, + "stringhe": "Ciaø, møndø. Tutti gli unicode sono permessi, assieme con l \"escaping\".", + "ha booleani?": true, + "il nulla": null, + + "numero grande": 1.2e+100, + + "oggetti": { + "commento": "La maggior parte della tua struttura viene dagli oggetti.", + + "array": [0, 1, 2, 3, "Gli array possono contenere qualsiasi cosa.", 5], + + "un altro oggetto": { + "commento": "Queste cose possono essere annidate, molto utile." + } + }, + + "sciocchezze": [ + { + "sorgenti di potassio": ["banane"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "stile alternativo": { + "commento": "Guarda quà!" + , "posizione della virgola": "non conta - fintantochè è prima del valore, allora è valida" + , "un altro commento": "che bello" + }, + + "è stato molto breve": "Ed hai finito. Adesso sai tutto cio che JSON ha da offrire." +} +``` diff --git a/ja-jp/bash-jp.html.markdown b/ja-jp/bash-jp.html.markdown new file mode 100644 index 00000000..88e5ff1c --- /dev/null +++ b/ja-jp/bash-jp.html.markdown @@ -0,0 +1,172 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] +translators: + - ["akirahirose", "https://twitter.com/akirahirose"] +filename: LearnBash-jp.sh +lang: ja-jp +--- + +Bash はunixシェルの1つです。GNUオペレーションシステムのシェルとして配布されています。 +LinuxやMac OS Xの、デフォルトシェルにもなっています。 +以下にある例は、ほぼ全部シェルスクリプトの一部として使えます。また、一部はそのままシェルから実行できます。 + +[ちゃんとした説明は、こちらをどうぞ](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# 最初の行はShebang(シェバング、シバン)というもので、システムに対して何を使って実行するのかを教えるためのものです +# ちゃんとした説明、こちらをどうぞ: http://en.wikipedia.org/wiki/Shebang_(Unix) +# 既にお気づきのように、コメント行は#で始まります. Shebangもコメントです + +# まずは Hello world です +echo Hello world! + +# コマンド毎に改行を入れるか、セミコロンで区切ります +echo 'This is the first line'; echo 'This is the second line' + +# 変数の宣言はこのようにやります +VARIABLE="Some string" + +# が、以下のようにやってはダメです +VARIABLE = "Some string" +# このように（空白を入れて）書くと、Bash はVARIABLEを実行するべきコマンドとみなし、実行します。 +# そして、VARIABLEというコマンドはない（はずな）ので、エラーになります + + +# 変数の使い方 +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# 変数の値（中身）を使わず、変数名だけを使うとき（代入するときや渡すときなど）は、$なしで変数名を書いてください +# 変数の値（中身）を使うときは、$をつけます +# 上記例の最後にある、' (シングルクォート) で囲んだ場合は、変数の値は表示されません! + +# 変数値の文字列置換 +echo ${VARIABLE/Some/A} +# 最初に出てくる "Some" を "A" で置換します + +# 変数値の一部を取り出します +echo ${VARIABLE:0:7} +# 最初の7文字だけを取り出します + +# デフォルトの変数値設定(訳注:シェル実行時に引数で変数値を設定できるが、設定しなかった場合の値を指定できる） +echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"} +# 上記は、FOO番目の引数がnullだったとき(FOO番目=)や、空文字が指定されたとき(FOO番目="")に、変数に0を入れます +# ( 当然ですが、引数に0を指定したとき(FOO番目=0) も、0は入ります） + +# 組込み変数 +# 以下のような便利な組込み変数があります +echo "Last program return value: $?" +echo "Script's PID: $$" +echo "Number of arguments: $#" +echo "Scripts arguments: $@" +echo "Scripts arguments seperated in different variables: $1 $2..." + +# 入力値の読み込み +echo "What's your name?" +read NAME # 新しく変数を宣言する必要はないことに注意 +echo Hello, $NAME! + +# 普通のif文も使えます +# 利用できる判定条件については、'man test' で参照してください +if [ $NAME -ne $USER ] +then + echo "Your name is your username" +else + echo "Your name isn't your username" +fi + +# 他にも、条件判定ができます +echo "Always executed" || echo "Only executed if first command fails" +echo "Always executed" && echo "Only executed if first command does NOT fail" + +# 数式は以下のように書きます +echo $(( 10 + 5 )) + +# 他のプログラム言語とは違ってbashはシェルなので、現在いるディレクトリ位置が異なると、異なる結果になります +# lsコマンドで、現在いるディレクトリにあるファイルと、ディレクトリのリストが取得できます +ls + +# これらのコマンドには、実行オプションがいろいろあります +ls -l # ファイルとディレクトリのリストを行に分けて表示します + +# あるコマンド実行による返値を、次のコマンドの入力値としてつかえます +# 例えばですが、lsコマンドの返値を、grepコマンドによって指定したルールに基づいてフィルタできます。 +# 以下は、現在いるディレクトリにある、.txtファイルのリストを表示する例です +ls -l | grep "\.txt" + +# コマンドに対する入力元や出力先、またエラー出力先などを変更できます +python2 hello.py < "input.in" +python2 hello.py > "output.out" +python2 hello.py 2> "error.err" +# 出力先として指定したファイルが既に存在する場合は、上書きされます +# もしもファイルに追記したい場合は、代わりに">>" を使ってください + +# コマンド文中で、$()内に別コマンドを入れると、その別コマンドの返値をコマンド文の一部として使う事ができます +# 次のコマンドは、現在いるディレクトリにあるファイルの数を表示します +echo "There are $(ls | wc -l) items here." + +# バッククォート(backticks) `` でも同じことができますが、入れ子にはできません +# そのため、$()がお勧めです +echo "There are `ls | wc -l` items here." + +# BashはJavaやC++のように、case文による分岐ができます +case "$VARIABLE" in + #分岐条件として使いたいパターンを並べてください + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# 指定した回数、処理を繰り返し +# 変数の値 $VARIABLE が3回表示されます +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# while ループです +while [true] +do + echo "loop body here..." + break +done + +# 関数の定義もできます +function foo () +{ + echo "Arguments work just like script arguments: $@" + echo "And: $1 $2..." + echo "This is a function" + return 0 +} + +# 以下のように、もっと簡単な書き方もあります +bar () +{ + echo "Another way to declare functions!" + return 0 +} + +# 自作関数を呼びます +foo "My name is" $NAME + +# 他にもいろいろと、知っておくと便利なコマンドがあります +# file.txtの最後10行を表示します +tail -n 10 file.txt +# file.txtの最初10行を表示します +head -n 10 file.txt +# file.txt's の行を並び替えます +sort file.txt +# 重複している行を表示するか、削除できます。-dオプションをつけると、表示します +uniq -d file.txt +# 1行ごとに、','が最初に出てくる前の部分を表示します +cut -d ',' -f 1 file.txt + +``` diff --git a/ja-jp/julia-jp.html.markdown b/ja-jp/julia-jp.html.markdown new file mode 100644 index 00000000..0c3160a2 --- /dev/null +++ b/ja-jp/julia-jp.html.markdown @@ -0,0 +1,762 @@ +--- +language: Julia +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Yuichi Motoyama", "https://github.com/yomichi"] +filename: learnjulia-jp.jl +lang: ja-jp +--- + +Julia は科学技術計算向けに作られた、同図像性を持った(homoiconic) プログラミング言語です。 +マクロによる同図像性や第一級関数などの抽象化機能の恩恵を受けつつ、低階層をも扱えますが、 +それでいてPython 並に学習しやすく、使いやすい言語となっています。 + +この文章は、Julia の2013年10月18日現在の開発バージョンを元にしています。 + +```ruby + +# ハッシュ（シャープ）記号から改行までは単一行コメントとなります。 +#= 複数行コメントは、 + '#=' と '=#' とで囲むことで行えます。 + #= + 入れ子構造にすることもできます。 + =# +=# + +#################################################### +## 1. 基本的な型と演算子 +#################################################### + +# Julia ではすべて式となります。 + +# 基本となる数値型がいくつかあります。 +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# 一般的な中置演算子が使用可能です。 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # 整数型同士の割り算の結果は、浮動小数点数型になります +div(5, 2) # => 2 # 整数のまま割り算するには、 div を使います +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # べき乗です。排他的論理和ではありません +12 % 10 # => 2 + +# 丸括弧で演算の優先順位をコントロールできます +(1 + 3) * 2 # => 8 + +# ビット演算 +~2 # => -3 # ビット反転 +3 & 5 # => 1 # ビット積 +2 | 4 # => 6 # ビット和 +2 $ 4 # => 6 # ビット排他的論理和 +2 >>> 1 # => 1 # 右論理シフト +2 >> 1 # => 1 # 右算術シフト +2 << 1 # => 4 # 左シフト + +# bits 関数を使うことで、数の二進表現を得られます。 +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# ブール値が用意されています +true +false + +# ブール代数 +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# 比較演算子をつなげることもできます +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# 文字列は " で作れます +"This is a string." + +# 文字リテラルは ' で作れます +'a' + +# 文字列は文字の配列のように添字アクセスできます +"This is a string"[1] # => 'T' # Julia では添字は 1 から始まります +# ただし、UTF8 文字列の場合は添字アクセスではうまくいかないので、 +# イテレーションを行ってください(map 関数や for ループなど) + +# $ を使うことで、文字列に変数や、任意の式を埋め込めます。 +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" + +# 他にも、printf マクロを使うことでも変数を埋め込めます。 +@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 + +# 出力も簡単です +println("I'm Julia. Nice to meet you!") + +#################################################### +## 2. 変数と配列、タプル、集合、辞書 +#################################################### + +# 変数の宣言は不要で、いきなり変数に値を代入・束縛できます。 +some_var = 5 # => 5 +some_var # => 5 + +# 値に束縛されていない変数を使おうとするとエラーになります。 +try + some_other_var # => ERROR: some_other_var not defined +catch e + println(e) +end + +# 変数名は数字や記号以外の文字から始めます。 +# その後は、数字やアンダースコア(_), 感嘆符(!)も使えます。 +SomeOtherVar123! = 6 # => 6 + +# Unicode 文字も使えます。 +☃ = 8 # => 8 +# ギリシャ文字などを使うことで数学的な記法が簡単にかけます。 +2 * π # => 6.283185307179586 + +# Julia における命名習慣について: +# +# * 変数名における単語の区切りにはアンダースコアを使っても良いですが、 +# 使わないと読みにくくなる、というわけではない限り、 +# 推奨はされません。 +# +# * 型名は大文字で始め、単語の区切りにはキャメルケースを使います。 +# +# * 関数やマクロの名前は小文字で書きます。 +# 単語の分かち書きにはアンダースコアをつかわず、直接つなげます。 +# +# * 内部で引数を変更する関数は、名前の最後に ! をつけます。 +# この手の関数は、しばしば「破壊的な関数」とか「in-place な関数」とか呼ばれます。 + + +# 配列は、1 から始まる整数によって添字付けられる、値の列です。 +a = Int64[] # => 0-element Int64 Array + +# 一次元配列（列ベクトル）は、角括弧 [] のなかにカンマ , 区切りで値を並べることで作ります。 +b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# 二次元配列は、空白区切りで作った行を、セミコロンで区切ることで作ります。 +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] + +# 配列の末尾に値を追加するには push! を、 +# 他の配列を結合するには append! を使います。 +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# 配列の末尾から値を削除するには pop! を使います。 +pop!(b) # => 6 and b is now [4,5] + +# 一旦元に戻しておきましょう。 +push!(b,6) # b is now [4,5,6] again. + +a[1] # => 1 # Julia では添字は0 ではなく1 から始まること、お忘れなく! + +# end は最後の添字を表す速記法です。 +# 添字を書く場所ならどこにでも使えます。 +a[end] # => 6 + +# 先頭に対する削除・追加は shift!, unshift! です。 +shift!(a) # => 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# ! で終わる関数名は、その引数を変更するということを示します。 +arr = [5,4,6] # => 3-element Int64 Array: [5,4,6] +sort(arr) # => [4,5,6]; arr is still [5,4,6] +sort!(arr) # => [4,5,6]; arr is now [4,5,6] + +# 配列の範囲外アクセスをすると BoundsError が発生します。 +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# エラーが発生すると、どのファイルのどの行で発生したかが表示されます。 +# 標準ライブラリで発生したものでもファイル名と行数が出ます。 +# ソースからビルドした場合など、標準ライブラリのソースが手元にある場合は +# base/ ディレクトリから探し出して見てください。 + +# 配列は範囲オブジェクトから作ることもできます。 +a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5] + +# 添字として範囲オブジェクトを渡すことで、 +# 配列の部分列を得ることもできます。 +a[1:3] # => [1, 2, 3] +a[2:end] # => [2, 3, 4, 5] + +# 添字を用いて配列から値の削除をしたい場合は、splice! を使います。 +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr is now [3,5] + +# 配列の結合は append! です。 +b = [1,2,3] +append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3] + +# 配列内に指定した値があるかどうかを調べるのには in を使います。 +in(1, a) # => true + +# length で配列の長さを取得できます。 +length(a) # => 8 + +# 変更不可能 (immutable) な値の組として、タプルが使えます。 +tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# 配列に関する関数の多くが、タプルでも使えます。 +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +# タプルから値をばらして(unpack して) 複数の変数に代入できます。 +a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3 + +# 丸括弧なしでもタプルになります。 +d, e, f = 4, 5, 6 # => (4,5,6) + +# ひとつの値だけからなるタプルは、その値自体とは区別されます。 +(1,) == 1 # => false +(1) == 1 # => true + +# 値の交換もタプルを使えば簡単です。 +e, d = d, e # => (5,4) # d is now 5 and e is now 4 + + +# 辞書 (Dict) は、値から値への変換の集合です。 +empty_dict = Dict() # => Dict{Any,Any}() + +# 辞書型リテラルは次のとおりです。 +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# [] を使ったアクセスができます。 +filled_dict["one"] # => 1 + +# すべての鍵（添字）は keys で得られます。 +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# 必ずしも辞書に追加した順番には並んでいないことに注意してください。 + +# 同様に、values はすべての値を返します。 +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# 鍵と同様に、必ずしも辞書に追加した順番には並んでいないことに注意してください。 + +# in や haskey を使うことで、要素や鍵が辞書の中にあるかを調べられます。 +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# 存在しない鍵を問い合わせると、エラーが発生します。 +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# get 関数を使い、鍵がなかった場合のデフォルト値を与えておくことで、 +# このエラーを回避できます。 +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# 集合 (Set) は一意な値の、順序付けられていない集まりです。 +empty_set = Set() # => Set{Any}() +# 集合の初期化 +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# 集合への追加 +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# in で、値が既に存在するかを調べられます。 +in(2, filled_set) # => true +in(10, filled_set) # => false + +# 積集合や和集合、差集合を得る関数も用意されています。 +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + + +#################################################### +## 3. 制御構文 +#################################################### + +# まずは変数を作ります。 +some_var = 5 + +# if 構文です。Julia ではインデントに意味はありません。 +if some_var > 10 + println("some_var is totally bigger than 10.") +elseif some_var < 10 # elseif 節は省略可能です。 + println("some_var is smaller than 10.") +else # else 節も省略可能です。 + println("some_var is indeed 10.") +end +# => "some var is smaller than 10" と出力されます。 + +# for ループによって、反復可能なオブジェクトを走査できます。 +# 反復可能なオブジェクトの型として、 +# Range, Array, Set, Dict, String などがあります。 +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # $ を使うことで文字列に変数の値を埋め込めます。 + # You can use $ to interpolate variables or expression into strings +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# for = の代わりに for in を使うこともできます +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# 辞書ではタプルが返ってきます。 +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# タプルのアンパック代入もできます。 +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# while ループは、条件式がtrue となる限り実行され続けます。 +x = 0 +while x < 4 + println(x) + x += 1 # Shorthand for x = x + 1 +end +# prints: +# 0 +# 1 +# 2 +# 3 + +# 例外は try/catch で捕捉できます。 +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. 関数 +#################################################### + +# function キーワードを次のように使うことで、新しい関数を定義できます。 +#function name(arglist) +# body... +#end +function add(x, y) + println("x is $x and y is $y") + + # 最後に評価された式の値が、関数全体の返り値となります。 + x + y +end + +add(5, 6) # => 11 after printing out "x is 5 and y is 6" + +# 可変長引数関数も定義できます。 +function varargs(args...) + return args + # return キーワードを使うことで、好きな位置で関数から抜けられます。 +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# ... はsplat と呼ばれます +# （訳注：「ピシャッという音（名詞）」「衝撃で平らにする（動詞）」） +# 今回は関数定義で使いましたが、関数呼び出しに使うこともできます。 +# その場合、配列やタプルの要素を開いて、複数の引数へと割り当てることとなります。 +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # 「整数の配列」の集合 +Set([1,2,3]...) # => Set{Int64}(1,2,3) # 整数の集合 + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # タプルの集合 +Set(x...) # => Set{Int64}(2,3,1) + + +# 引数に初期値を与えることで、オプション引数をもった関数を定義できます。 +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# キーワード引数を持った関数も作れます。 +function keyword_args(;k1=4,name2="hello") # ; が必要なことに注意 + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] + +# もちろん、これらを組み合わせることもできます。 +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# prints: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Julia では関数は第一級関数として、値として扱われます。 +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# ラムダ式によって無名関数をつくれます。 +(x -> x > 2)(3) # => true + +# 先ほどの create_adder と同じもの +function create_adder(x) + y -> x + y +end + +# 中の関数に名前をつけても構いません。 +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# いくつかの高階関数が定義されています。 +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# map の代わりとしてリスト内包表記も使えます。 +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. 型 +#################################################### + +# Julia ではすべての値にひとつの型がついています。 +# 変数に、ではなくて値に、です。 +# typeof 関数を使うことで、値が持つ型を取得できます。 +typeof(5) # => Int64 + +# 型自身もまた、第一級の値であり、型を持っています。 +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType は型を表現する型であり、DataType 自身もDataType 型の値です。 + +# 型はドキュメント化や最適化、関数ディスパッチのために使われます。 +# 静的な型チェックは行われません。 + +# 自分で新しい型を定義することもできます。 +# 他の言語で言う、構造体やレコードに近いものになっています。 +# 型定義には type キーワードを使います。 +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # 型注釈を省略した場合、自動的に :: Any として扱われます。 +end + +# 型を定義すると、その型のプロパティすべてを、定義した順番に +# 引数として持つデフォルトコンストラクタが自動的に作られます。 +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# 型名がそのままコンストラクタ名（関数名）となります。 +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# このような、構造体スタイルの型は、具体型(concrete type)と呼ばれます。 +# 具体型はインスタンス化可能ですが、派生型(subtype)を持つことができません。 +# 具体型の他には抽象型(abstract type)があります。 + +# abstract Name +abstract Cat # 型の階層図の途中の一点を指し示す名前となります。 + +# 抽象型はインスタンス化できませんが、派生型を持つことができます。 +# 例えば、 Number は以下の派生型を持つ抽象型です。 +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# すべての型は、直接的にはただひとつの基本型(supertype) を持ちます。 +# super 関数でこれを取得可能です。 +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# Int64 を除き、これらはすべて抽象型です。 + +# <: は派生形を表す演算子です。 +# これを使うことで派生型を定義できます。 +type Lion <: Cat # Lion は 抽象型 Cat の派生型 + mane_color + roar::String +end + +# 型名と同じ名前の関数を定義し、既に存在するコンストラクタを呼び出して、 +# 必要とする型の値を返すことによって、 +# デフォルトコンストラクタ以外のコンストラクタを作ることができます。 + +Lion(roar::String) = Lion("green",roar) +# 型定義の外側で定義されたコンストラクタなので、外部コンストラクタと呼ばれます。 + +type Panther <: Cat # Panther も Cat の派生型 + eye_color + Panther() = new("green") + # Panther は内部コンストラクタとしてこれのみを持ち、 + # デフォルトコンストラクタを持たない +end +# 内部コンストラクタを使うことで、どのような値が作られるのかをコントロールすることができます。 +# 出来る限り、外部コンストラクタを使うべきです。 + +#################################################### +## 6. 多重ディスパッチ +#################################################### + +# Julia では、すべての名前付きの関数は総称的関数(generic function) です。 +# これは、関数はいくつかの細かいメソッドの集合である、という意味です。 +# 例えば先の Lion 型のコンストラクタ Lion は、Lion という関数の1つのメソッドです。 + +# コンストラクタ以外の例をみるために、新たに meow 関数を作りましょう。 + +# Lion, Panther, Tiger 型それぞれに対する meow 関数のメソッド定義 +function meow(animal::Lion) + animal.roar # 型のプロパティには . でアクセスできます。 +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# meow 関数の実行 +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# 型の階層関係を見てみましょう +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# 抽象型 Cat の派生型を引数にとる関数 +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => prints "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# オブジェクト指向言語では、一般的にシングルディスパッチが用いられます。 +# つまり、関数に複数あるメソッドのうちにどれが呼ばれるかは、 +# その第一引数（もしくは、 . や -> の前にある値の型）によってのみ決定されます。 +# 一方でJulia では、すべての引数の型が、このメソッド決定に寄与します。 + +# 多変数関数を定義して、この辺りを見て行きましょう。 +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The orange tiger wins! + +# 第二引数の Cat が実際は Lion だった時に、挙動が変わるようにします。 +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins! + +# 別に Tiger だけが戦う必要もないですね。 +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# 第一引数にも Cat を許しましょう。 +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# 警告が出ましたが、これは次の対戦で何が起きるのかが不明瞭だからです。 +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr +# Julia のバージョンによっては、結果が違うかもしれません。 + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie + + +# Julia が生成する LLVM 内部表現や、アセンブリを調べることもできます。 + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# square_area に整数を渡すと何が起きる？ +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prologue + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # l を取得 + # imul RAX, RAX # l*l を計算して RAX に入れる + # pop RBP # Base Pointer を元に戻す + # ret # 終了。RAX の中身が結果 + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # 単精度浮動小数点数演算 (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # 倍精度浮動小数点数演算 (AVX) + # pop RBP + # ret + # + +# Julia では、浮動小数点数と整数との演算では +# 自動的に浮動小数点数用の命令が生成されることに注意してください。 +# 円の面積を計算してみましょう。 +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory + # movabs RAX, 4593140240 # Load pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## より勉強するために + +[公式ドキュメント](http://docs.julialang.org/en/latest/manual/) (英語)にはより詳細な解説が記されています。 + +Julia に関して助けが必要ならば、[メーリングリスト](https://groups.google.com/forum/#!forum/julia-users) が役に立ちます。 +みんな非常に親密に教えてくれます。 + diff --git a/ja-jp/r-jp.html.markdown b/ja-jp/r-jp.html.markdown new file mode 100644 index 00000000..a8dd7c9c --- /dev/null +++ b/ja-jp/r-jp.html.markdown @@ -0,0 +1,775 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["akirahirose", "https://twitter.com/akirahirose"] +filename: learnr-jp.r +lang: ja-jp +--- + + +R は統計計算用の言語です。 +データの取得やクリーニング、統計処理やグラフ作成をするために便利な、たくさんのライブラリがあります。また、LaTeX文書からRコマンドを呼び出すこともできます + + +```r +# コメント行は、#で開始します + + +# 複数行をまとめてコメントにすることはできないので、 +# コメントを複数の行に分けたい場合、このように、単に毎行をコメントにしてください + + +# WindowsやMacでは、 COMMAND-ENTERで、コマンドを1行実行できます + + + + + + +############################################################################# +# プログラミングがわからなくとも使えるコマンド類 +############################################################################# + + +# この節では、プログラミングがわからなくとも使える便利なRコマンドを紹介します +# 全てを理解できなくとも、まずはやってみましょう！ + + +data() # 既にロードされているデータを閲覧します +data(rivers) # "北米にある大きな川の長さ"データを取得します +ls() # "rivers" がワークスペースに表示されました +head(rivers) # データの先頭部分です +# 735 320 325 392 524 450 + + +length(rivers) # 何本の川がデータにある? +# 141 +summary(rivers) # 統計的に要約するとどうなる? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + + +# 茎葉図（ヒストグラムに似た図）を描く +stem(rivers) + + +# The decimal point is 2 digit(s) to the right of the | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + + +stem(log(rivers)) # このデータは、正規分布でも対数正規分布でもないので、注意！ +# 特に正規分布原理主義のみなさん + + +# The decimal point is 1 digit(s) to the left of the | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + + +# ヒストグラム作成 +hist(rivers, col="#333333", border="white", breaks=25) # これらのパラメータをつかいます +hist(log(rivers), col="#333333", border="white", breaks=25) # いろいろな使い方ができます + + +# 別のロード済データでやってみましょう。Rには、いろいろなデータがロードされています。 +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + + +# 年次のソートだけではなく、 +# 標準的な並べ替えもできます +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + + +stem(discoveries, scale=2) +# +# The decimal point is at the | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + + +# サイコロを振ります +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# 私と同じrandom.seed(31337)を使わない限りは、別の値になります + + +# ガウス分布を9回生成します +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + + + + +################################################## +# データ型と基本計算 +################################################## + + +# ここからは、プログラミングをつかうチュートリアルです +# この節ではRで重要なデータ型（データクラス）の、整数型、数字型、文字型、論理型と因子（ファクター）型をつかいます +# 他にもいろいろありますが、これらの必要最小限なものから始めましょう + + +# 整数型 +# 整数型はLで指定します +5L # 5 +class(5L) # "integer" +# (?class を実行すると、class()関数について、さらなる情報が得られます) +# Rでは、この5Lのような1つの値は、長さ1のベクトルとして扱われます +length(5L) # 1 +# 整数型のベクトルはこのようにつくります +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + + +# 数字型 +# 倍精度浮動小数点数です +5 # 5 +class(5) # "numeric" +# しつこいですが、すべてはベクトルです +# 1つ以上の要素がある数字のベクトルも、作ることができます +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# 指数表記もできます +5e4 # 50000 +6.02e23 # アボガドロ数 +1.6e-35 # プランク長 +# 無限大、無限小もつかえます +class(Inf) # "numeric" +class(-Inf) # "numeric" +# 例のように、"Inf"を使ってください。integrate( dnorm(x), 3, Inf); +# Z-スコア表が必要なくなります + + +# 基本的な計算 +# 数を計算できます +# 整数と整数以外の数字を両方使った計算をすると、結果は整数以外の数字になります +10L + 66L # 76 # 整数足す整数は整数 +53.2 - 4 # 49.2 # 整数引く数字は数字 +2.0 * 2L # 4 # 数字かける整数は数字 +3L / 4 # 0.75 # 整数割る数字は数字 +3 %% 2 # 1 # 二つの数字を割った余りは数字 +# 不正な計算は "not-a-number"になります +0 / 0 # NaN +class(NaN) # "numeric" +# 長さが1より大きなベクター同士の計算もできます +# どちらかが長い場合、短い方は何度も繰り返して使われます +c(1,2,3) + c(1,2,3) # 2 4 6 + +# 文字 +# Rでは、文字列と文字に区別がありません +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# 上記は両方とも、長さ1のベクターです +# 以下は、より長い場合です +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# => +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# 正規表現処理を文字ベクターに適用できます +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# Rはいくつかの文字ベクターを組み込みで持っています +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + + +# 論理 +# Rでは、Booleanは論理（logical）型です +class(TRUE) # "logical" +class(FALSE) # "logical" +# 以下は比較演算子の例です +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# 無いデータ (NA) も論理型です +class(NA) # "logical" +# 以下のようにすると、複数の要素を持つ、論理型ベクターが返ります +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE + + +# 因子（ファクター） +# 因子型は、カテゴリカルデータ用の型です +# 因子には、子供の学年のように順序がつけられるものか、性別のように順序がないものがあります +factor(c("female", "female", "male", "NA", "female")) +# female female male NA female +# Levels: female male NA +# "levels" は、カテゴリカルデータがとりうる値を返します +levels(factor(c("male", "male", "female", "NA", "female"))) # "female" "male" "NA" +# 因子ベクターの長さが1ならば、そのlevelも1です +length(factor("male")) # 1 +length(levels(factor("male"))) # 1 +# 因子型は、この後で紹介するデータフレーム（というデータ型）内で、よくみられます +data(infert) # "Infertility after Spontaneous and Induced Abortion" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + + +# NULL +# "NULL" は特殊な型なのですが、ベクターを空にするときに使います +class(NULL) # NULL +parakeet +# => +# [1] "beak" "feathers" "wings" "eyes" +parakeet <- NULL +parakeet +# => +# NULL + + +# 型の強制 +# 型の強制とは、ある値を、強制的に別の型として利用する事です +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# さまざまな要素が入っているベクターに対して型の強制を行うと、おかしなことになります +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Warning message: +# NAs introduced by coercion + + +# 追記: ここで紹介したのは、基本的な型だけです +# 実際には、日付（dates）や時系列（time series）など、いろいろな型があります + + + + + + +################################################## +# 変数、ループ、もし/ほかに（if/else） +################################################## + + +# 変数は、ある値を後で使うために入れておく、箱のようなものです +# 箱に入れることを、変数に値を代入する、といいます +# 変数を使うと、ループや関数、if/else 分岐を利用できます + + +# 変数 +# 代入する方法はいろいろあります +x = 5 # これはできます +y <- "1" # これがおすすめです +TRUE -> z # これも使えますが、ちょっとわかりにくいですね + + +# ループ +# forでループできます +for (i in 1:4) { + print(i) +} +# whileでループできます +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} +# Rでは、forやwhileは遅いことを覚えておいてください +# ベクターを丸ごと処理する（つまり、行全体や、列全体を指定して処理する）か、 +# 後述する、apply()系の関数を使うのが、速度的にはお勧めです + + +# IF/ELSE +# ごく普通のif文です +if (4 > 3) { + print("4 is greater than 3") +} else { + print("4 is not greater than 3") +} +# => +# [1] "4 is greater than 3" + + +# 関数 +# 以下のように定義します +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) #すこしだけ（制御された）ノイズを入れます + return(x) +} +# 他の関数と同じように、呼びます +jiggle(5) # 5±ε. set.seed(2716057)をすると、jiggle(5)==5.005043 + + + + + + +########################################################################### +# データ構造: ベクター、行列、データフレーム、配列 +########################################################################### + + +# 1次元 + + +# まずは基本からです。ご存じベクターからです +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# 特定の要素を、[角括弧]による指定で取り出せます +# (Rでは、最初の要素は1番目と数えます) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 +# 特定のルールに当てはまる要素を見つけることもできます +which(vec %% 2 == 0) # 1 3 +# 最初か最後の数個を取り出すこともできます +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ある値がベクターにあるかどうかをみることができます +any(vec == 10) # TRUE +# ベクターの数より大きなインデックスを指定すると、NAが返ります +vec[6] # NA +# ベクターの長さは、length()で取得できます +length(vec) # 4 +# ベクター全体、または1部に対して、操作ができます +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# R には、ベクターにある値を要約するための様々な関数があります +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# 他にも、ベクター関連ではいろいろな関数があります。以下はベクターをつくるための方法です +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + + +# 2次元配列 (すべての値が同じ型の場合) + + +# 同じ型の値が含まれる2次元配列は、このように作れます +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# ベクターとは違い、2次元配列の型名は"matrix"です。 +class(mat) # => "matrix" +# 最初の行 +mat[1,] # 1 4 +# 最初の列に対する操作 +3 * mat[,1] # 3 6 9 +# 特定のセルを取り出し +mat[3,2] # 6 + + +# 2次元配列全体を転置します +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + + +# 2次元配列の積 +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + + +# cbind() は、複数のベクターを、別々の列に並べて2次元配列を作ります +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" +# [4,] "4" "dog" +class(mat2) # matrix +# ここでいま1度、2次元配列内の型について注意してください! +# 2次元配列にある値は、すべて同じ型にする必要があります。そのため、すべて文字型に変換されています +c(class(mat2[,1]), class(mat2[,2])) + + +# rbind() は、複数のベクターを、別々の行に並べて2次元配列を作ります +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# 全ての値は同じ型になります。上記例は幸い、強制変換がされないものでした + + +# 2次元配列 (いろいろな型を含む場合) + + +# 異なる型の値を含む配列をつくりたい場合、データフレームを使ってください +# データフレームは、統計処理を行うプログラムをする際にとても便利です +# Pythonでも、 "pandas"というパッケージにて、似たものが利用可能です + + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") #カラム名 +class(students) # "data.frame" +students +# => +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# 行と列の数をみます +nrow(students) # 6 +ncol(students) # 3 +dim(students) # 6 3 +# このdata.frame() 関数は、デフォルトでは文字列ベクターを因子ベクターに変換します +# stringsAsFactors = FALSE に設定してからデータフレームを作成すると、変換されません +?data.frame + + +# データフレームの1部を取り出すには、いろいろな（変な）、似たような方法があります +students$year # 3 2 2 1 0 -1 +students[,2] # 3 2 2 1 0 -1 +students[,"year"] # 3 2 2 1 0 -1 + + +# データフレームの拡張版が、データテーブルです。 +# 大きなデータやパネルデータ、データセットの結合が必要な場合には、データテーブルを使うべきです。 +# 以下に駆け足で説明します +install.packages("data.table") # CRANからパッケージをダウンロードします +require(data.table) # ロードします +students <- as.data.table(students) +students # 若干異なる出力がされることに注意 +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # name == "Ginny"の行を取り出します +# => +# name year house +# 1: Ginny -1 G +students[year==2] # year == 2の行を取り出します +# => +# name year house +# 1: Fred 2 G +# 2: George 2 G +# データテーブルは、二つのデータセットを結合するのにも便利です +# 結合用に、生徒データが入った別のデータテーブルをつくります +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # 二つのデータテーブルを、"house"をキーとして結合します +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + + +# データテーブルは、要約を作るのも簡単です +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + + +# データフレームやデータテーブルから列を消したい場合は、NULL値を代入します +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + + +# データテーブルから行を消す場合は、以下のように除く行を指定すればできます +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# データフレームの場合も同様です +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + + +# 多次元 (すべての値が同じ型の場合) + + +# 配列を並べて、N次元の表を作ります +# 配列なので、すべての値は同じ型にする必要があります +# ちなみに、以下のようにすれば2次元配列・2次元表も作成可能です +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# 2次元配列を並べて、3次元配列を作ることもできます +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + + +# リスト（多次元、不完全または複数の型が使われているもの) + + +# ついにRのリストです +list1 <- list(time = 1:40) +list1$price = c(rnorm(40,.5*list1$time,4)) # random +list1 +# リストの要素は以下のようにして取得できます +list1$time # ある方法 +list1[["time"]] # 別の方法 +list1[[1]] # また別の方法 +# => +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# 他のベクターと同じく、1部を取り出すことができます +list1$price[4] + + +# リストは、Rで1番効率的なデータ型ではありません +# 特別な理由がない限りは、リストの代わりにデータフレームを使うべきです +# リストは、線形回帰関数の返値として、しばしば使われています + + +################################################## +# apply() 系の関数 +################################################## + + +# matは覚えていますよね？ +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# apply(X, MARGIN, FUN) は、行列Xの行（MARGIN=1で指定)または列（MARGIN=2で指定)に対して、関数FUNを実行します +# Rで、このように指定してXの全行または全列に関数を実行するのは、forやwhileループを使うよりも、遥かに速いです +apply(mat, MAR = 2, jiggle) +# => +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# 他にも便利な関数があります。?lapply, ?sapply で確認してみてください + + +# apply()系関数の使い方は、ちょっとややこしいです（みんなそう思ってます）。なので、あまり怖がりすぎないでください + + +# plyr パッケージは、*apply() 系の関数を置き換えて（さらに改善して）いこうとしています +install.packages("plyr") +require(plyr) +?plyr + + + + + + +######################### +# データロード +######################### + + +# "pets.csv"は、インターネット上に置いてあるファイルです +# (しかし、自分のPCにあるのと同じぐらい簡単に扱う事ができます) +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +pets +head(pets, 2) # 最初の2行 +tail(pets, 1) # 最後の行 + + +# データフレームか行列をcsvファイルとして保存します +write.csv(pets, "pets2.csv") # 新しくcsvファイルを作ります +# ワーキングディレクトリを、setwd()で設定します。 ワーキングディレクトリは getwd()で確認可能です + + +# ?read.csv や ?write.csv を入力すると、よりたくさんの情報を確認できます + + + + + + +######################### +# プロット +######################### + + +# Rに組込まれているプロット関数をつかいます +# 散布図! +plot(list1$time, list1$price, main = "fake data") +# 回帰図! +linearModel <- lm(price ~ time, data = list1) +linearModel # outputs result of regression +# 回帰直線を既存の図上に引きます +abline(linearModel, col = "red") +# いろいろな散布図をつくって、確認できます +plot(linearModel) +# ヒストグラム！ +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# 棒グラフ！ +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + + +# GGPLOT2 +# 上記の組込み関数を使うよりも、もっときれいな図を描くこともできます +# ggplot2 パッケージを使って、より多くのよい図を描いてみましょう +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(students, aes(x=house)) +pp + geom_histogram() +ll <- as.data.table(list1) +pp <- ggplot(ll, aes(x=time,price)) +pp + geom_point() +# ggplot2 には、素晴らしい関連ドキュメントがそろっています (http://docs.ggplot2.org/current/) + + + + + + +``` + + +## Rの入手方法 + + +* RとR GUIはこちら [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) 別のGUI diff --git a/java.html.markdown b/java.html.markdown index b4531635..fc7948d6 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -1,14 +1,16 @@ --- - language: java contributors: - ["Jake Prather", "http://github.com/JakeHP"] + - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Madison Dickson", "http://github.com/mix3d"] + - ["Simon Morgan", "http://sjm.io/"] filename: LearnJava.java - --- -Java is a general-purpose, concurrent, class-based, object-oriented computer programming language. -[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html) +Java is a general-purpose, concurrent, class-based, object-oriented computer +programming language. +[Read more here.](http://docs.oracle.com/javase/tutorial/java/) ```java // Single-line comments start with // @@ -25,29 +27,50 @@ import java.util.ArrayList; // Import all classes inside of java.security package import java.security.*; -// Each .java file contains one public class, with the same name as the file. +// Each .java file contains one outer-level public class, with the same name as +// the file. public class LearnJava { - // A program must have a main method as an entry point + // A program must have a main method as an entry point. public static void main (String[] args) { - // Use System.out.println to print lines + // Use System.out.println() to print lines. System.out.println("Hello World!"); System.out.println( "Integer: " + 10 + " Double: " + 3.14 + " Boolean: " + true); - // To print without a newline, use System.out.print + // To print without a newline, use System.out.print(). System.out.print("Hello "); System.out.print("World"); /////////////////////////////////////// - // Types & Variables + // Variables /////////////////////////////////////// - // Declare a variable using <type> <name> [ + /* + * Variable Declaration + */ + // Declare a variable using <type> <name> + int fooInt; + // Declare multiple variables of the same type <type> <name1>, <name2>, <name3> + int fooInt1, fooInt2, fooInt3; + + /* + * Variable Initialization + */ + + // Initialize a variable using <type> <name> = <val> + int fooInt = 1; + // Initialize multiple variables of same type with same value <type> <name1>, <name2>, <name3> = <val> + int fooInt1, fooInt2, fooInt3; + fooInt1 = fooInt2 = fooInt3 = 1; + + /* + * Variable types + */ // Byte - 8-bit signed two's complement integer // (-128 <= byte <= 127) byte fooByte = 100; @@ -66,7 +89,7 @@ public class LearnJava { // L is used to denote that this variable value is of type Long; // anything without is treated as integer by default. - // Note: Java has no unsigned types + // Note: Java has no unsigned types. // Float - Single-precision 32-bit IEEE 754 Floating Point float fooFloat = 234.5f; @@ -83,7 +106,7 @@ public class LearnJava { // Char - A single 16-bit Unicode character char fooChar = 'A'; - // Use final to make a variable immutable + // final variables can't be reassigned to another object. final int HOURS_I_WORK_PER_WEEK = 9001; // Strings @@ -98,15 +121,18 @@ public class LearnJava { System.out.println(bazString); // Arrays - //The array size must be decided upon declaration - //The format for declaring an array is follows: - //<datatype> [] <var name> = new <datatype>[<array size>]; - int [] intArray = new int[10]; - String [] stringArray = new String[1]; - boolean [] booleanArray = new boolean[100]; + // The array size must be decided upon instantiation + // The following formats work for declaring an array + // <datatype>[] <var name> = new <datatype>[<array size>]; + // <datatype> <var name>[] = new <datatype>[<array size>]; + int[] intArray = new int[10]; + String[] stringArray = new String[1]; + boolean boolArray[] = new boolean[100]; // Another way to declare & initialize an array - int [] y = {9000, 1000, 1337}; + int[] y = {9000, 1000, 1337}; + String names[] = {"Bob", "John", "Fred", "Juan Pedro"}; + boolean bools[] = new boolean[] {true, false, false}; // Indexing an array - Accessing an element System.out.println("intArray @ 0: " + intArray[0]); @@ -116,11 +142,17 @@ public class LearnJava { System.out.println("intArray @ 1: " + intArray[1]); // => 1 // Others to check out - // ArrayLists - Like arrays except more functionality is offered, - // and the size is mutable - // LinkedLists - // Maps - // HashMaps + // ArrayLists - Like arrays except more functionality is offered, and + // the size is mutable. + // LinkedLists - Implementation of doubly-linked list. All of the + // operations perform as could be expected for a + // doubly-linked list. + // Maps - A set of objects that maps keys to values. A map cannot + // contain duplicate keys; each key can map to at most one value. + // HashMaps - This class uses a hashtable to implement the Map + // interface. This allows the execution time of basic + // operations, such as get and insert element, to remain + // constant even for large sets. /////////////////////////////////////// // Operators @@ -148,22 +180,25 @@ public class LearnJava { // Bitwise operators! /* - ~ Unary bitwise complement - << Signed left shift - >> Signed right shift - >>> Unsigned right shift - & Bitwise AND - ^ Bitwise exclusive OR - | Bitwise inclusive OR + ~ Unary bitwise complement + << Signed left shift + >> Signed right shift + >>> Unsigned right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR */ // Incrementations int i = 0; System.out.println("\n->Inc/Dec-rementation"); - System.out.println(i++); //i = 1. Post-Incrementation - System.out.println(++i); //i = 2. Pre-Incrementation - System.out.println(i--); //i = 1. Post-Decrementation - System.out.println(--i); //i = 0. Pre-Decrementation + // The ++ and -- operators increment and decrement by 1 respectively. + // If they are placed before the variable, they increment then return; + // after the variable they return then increment. + System.out.println(i++); // i = 1, prints 0 (post-increment) + System.out.println(++i); // i = 2, prints 2 (pre-increment) + System.out.println(i--); // i = 1, prints 2 (post-decrement) + System.out.println(--i); // i = 0, prints 0 (pre-decrement) /////////////////////////////////////// // Control Structures @@ -182,62 +217,77 @@ public class LearnJava { // While loop int fooWhile = 0; - while(fooWhile < 100) - { - //System.out.println(fooWhile); - //Increment the counter - //Iterated 99 times, fooWhile 0->99 + while(fooWhile < 100) { + System.out.println(fooWhile); + // Increment the counter + // Iterated 100 times, fooWhile 0,1,2...99 fooWhile++; } System.out.println("fooWhile Value: " + fooWhile); // Do While Loop int fooDoWhile = 0; - do - { - //System.out.println(fooDoWhile); - //Increment the counter - //Iterated 99 times, fooDoWhile 0->99 + do { + System.out.println(fooDoWhile); + // Increment the counter + // Iterated 99 times, fooDoWhile 0->99 fooDoWhile++; - }while(fooDoWhile < 100); + } while(fooDoWhile < 100); System.out.println("fooDoWhile Value: " + fooDoWhile); // For Loop int fooFor; - //for loop structure => for(<start_statement>; <conditional>; <step>) - for(fooFor=0; fooFor<10; fooFor++){ - //System.out.println(fooFor); - //Iterated 10 times, fooFor 0->9 + // for loop structure => for(<start_statement>; <conditional>; <step>) + for (fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // Iterated 10 times, fooFor 0->9 } System.out.println("fooFor Value: " + fooFor); + // For Each Loop + // The for loop is also able to iterate over arrays as well as objects + // that implement the Iterable interface. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // for each loop structure => for (<object> : <iterable>) + // reads as: for each element in the iterable + // note: the object type must match the element type of the iterable. + + for (int bar : fooList) { + System.out.println(bar); + //Iterates 9 times and prints 1-9 on new lines + } + // Switch Case // A switch works with the byte, short, char, and int data types. - // It also works with enumerated types (discussed in Enum Types), - // the String class, and a few special classes that wrap - // primitive types: Character, Byte, Short, and Integer. + // It also works with enumerated types (discussed in Enum Types), the + // String class, and a few special classes that wrap primitive types: + // Character, Byte, Short, and Integer. int month = 3; String monthString; - switch (month){ - case 1: - monthString = "January"; + switch (month) { + case 1: monthString = "January"; break; - case 2: - monthString = "February"; + case 2: monthString = "February"; break; - case 3: - monthString = "March"; - break; - default: - monthString = "Some other month"; + case 3: monthString = "March"; break; + default: monthString = "Some other month"; + break; } System.out.println("Switch Case Result: " + monthString); + // Conditional Shorthand + // You can use the '?' operator for quick assignments or logic forks. + // Reads as "If (statement) is true, use <first value>, otherwise, use + // <second value>" + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Prints A, because the statement is true - /////////////////////////////////////// - // Converting Data Types And Typcasting - /////////////////////////////////////// + + //////////////////////////////////////// + // Converting Data Types And Typecasting + //////////////////////////////////////// // Converting data @@ -253,9 +303,8 @@ public class LearnJava { // String // Typecasting - // You can also cast java objects, there's a lot of details and - // deals with some more intermediate concepts. - // Feel free to check it out here: + // You can also cast Java objects, there's a lot of details and deals + // with some more intermediate concepts. Feel free to check it out here: // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html @@ -274,20 +323,47 @@ public class LearnJava { trek.speedUp(3); // You should always use setter and getter methods trek.setCadence(100); - // toString is a convention to display the value of this Object. + // 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<String> COUNTRIES = new HashSet<String>(); + 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<String> COUNTRIES = HashSet<String>() {{ + 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 -// You can include other, non-public classes in a .java file +// You can include other, non-public outer-level classes in a .java file // Class Declaration Syntax: -// <public/private/protected> class <class name>{ -// //data fields, constructors, functions all inside. -// //functions are called as methods in Java. +// <public/private/protected> class <class name> { +// // data fields, constructors, functions all inside. +// // functions are called as methods in Java. // } class Bicycle { @@ -299,7 +375,7 @@ class Bicycle { String name; // default: Only accessible from within this package // Constructors are a way of creating classes - // This is a default constructor + // This is a constructor public Bicycle() { gear = 1; cadence = 50; @@ -307,8 +383,9 @@ class Bicycle { name = "Bontrager"; } - // This is a specified constructor (it contains arguments) - public Bicycle(int startCadence, int startSpeed, int startGear, String name) { + // This is a constructor that takes arguments + public Bicycle(int startCadence, int startSpeed, int startGear, + String name) { this.gear = startGear; this.cadence = startCadence; this.speed = startSpeed; @@ -354,10 +431,8 @@ class Bicycle { //Method to display the attribute values of this Object. @Override public String toString() { - return "gear: " + gear + - " cadence: " + cadence + - " speed: " + speed + - " name: " + name; + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + + " name: " + name; } } // end class Bicycle @@ -371,14 +446,124 @@ class PennyFarthing extends Bicycle { super(startCadence, startSpeed, 0, "PennyFarthing"); } - // You should mark a method you're overriding with an @annotation - // To learn more about what annotations are and their purpose - // check this out: http://docs.oracle.com/javase/tutorial/java/annotations/ + // You should mark a method you're overriding with an @annotation. + // To learn more about what annotations are and their purpose check this + // out: http://docs.oracle.com/javase/tutorial/java/annotations/ @Override public void setGear(int gear) { gear = 0; } +} + +// Interfaces +// Interface declaration syntax +// <access-level> interface <interface-name> extends <super-interfaces> { +// // Constants +// // Method declarations +// } + +// Example - Food: +public interface Edible { + public void eat(); // Any class that implements this interface, must + // implement this method. +} + +public interface Digestible { + public void digest(); +} + + +// We can now create a class that implements both of these interfaces. +public class Fruit implements Edible, Digestible { + @Override + public void eat() { + // ... + } + + @Override + public void digest() { + // ... + } +} + +// In Java, you can extend only one class, but you can implement many +// interfaces. For example: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, + InterfaceTwo { + @Override + public void InterfaceOneMethod() { + } + + @Override + public void InterfaceTwoMethod() { + } +} + +// Abstract Classes +// Abstract Class declaration syntax +// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> { +// // 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(); + } } ``` @@ -387,7 +572,7 @@ class PennyFarthing extends Bicycle { The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. -Other Topics To Research: +**Official Oracle Guides**: * [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) @@ -405,3 +590,20 @@ Other Topics To Research: * [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) * [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) + +**Online Practice and Tutorials** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Books**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Thinking in Java](http://www.mindview.net/Books/TIJ/) + +* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) + +* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300) diff --git a/javascript.html.markdown b/javascript.html.markdown index 9cc7617d..754832f1 100644 --- a/javascript.html.markdown +++ b/javascript.html.markdown @@ -1,11 +1,13 @@ --- language: javascript -author: Adam Brenecki -author_url: http://adam.brenecki.id.au +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +filename: javascript.js --- -Javascript was created by Netscape's Brendan Eich in 1995. It was originally -intended as a simpler scripting language for websites, complimenting the use of +JavaScript was created by Netscape's Brendan Eich in 1995. It was originally +intended as a simpler scripting language for websites, complementing the use of Java for more complex web applications, but its tight integration with Web pages and built-in support in browsers has caused it to become far more common than Java in web frontends. @@ -30,161 +32,187 @@ doStuff(); // wherever there's a newline, except in certain cases. doStuff() -// We'll leave semicolons off here; whether you do or not will depend on your -// personal preference or your project's style guide. +// Because those cases can cause unexpected results, we'll keep on using +// semicolons in this guide. /////////////////////////////////// // 1. Numbers, Strings and Operators -// Javascript has one number type (which is a 64-bit IEEE 754 double). -3 // = 3 -1.5 // = 1.5 +// JavaScript has one number type (which is a 64-bit IEEE 754 double). +// Doubles have a 52-bit mantissa, which is enough to store integers +// up to about 9✕10¹⁵ precisely. +3; // = 3 +1.5; // = 1.5 -// All the basic arithmetic works as you'd expect. -1 + 1 // = 2 -8 - 1 // = 7 -10 * 2 // = 20 -35 / 5 // = 7 +// Some basic arithmetic works as you'd expect. +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 // Including uneven division. -5 / 2 // = 2.5 +5 / 2; // = 2.5 // Bitwise operations also work; when you perform a bitwise operation your float // is converted to a signed int *up to* 32 bits. -1 << 2 // = 4 +1 << 2; // = 4 // Precedence is enforced with parentheses. -(1 + 3) * 2 // = 8 +(1 + 3) * 2; // = 8 // There are three special not-a-real-number values: -Infinity // result of e.g. 1/0 --Infinity // result of e.g. -1/0 -NaN // result of e.g. 0/0 +Infinity; // result of e.g. 1/0 +-Infinity; // result of e.g. -1/0 +NaN; // result of e.g. 0/0, stands for 'Not a Number' // There's also a boolean type. -true -false +true; +false; // Strings are created with ' or ". -'abc' -"Hello, world" +'abc'; +"Hello, world"; // Negation uses the ! symbol -!true // = false -!false // = true +!true; // = false +!false; // = true -// Equality is == -1 == 1 // = true -2 == 1 // = false +// Equality is === +1 === 1; // = true +2 === 1; // = false -// Inequality is != -1 != 1 // = false -2 != 1 // = true +// Inequality is !== +1 !== 1; // = false +2 !== 1; // = true // More comparisons -1 < 10 // = true -1 > 10 // = false -2 <= 2 // = true -2 >= 2 // = true +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true // Strings are concatenated with + -"Hello " + "world!" // = "Hello world!" +"Hello " + "world!"; // = "Hello world!" // and are compared with < and > -"a" < "b" // = true +"a" < "b"; // = true -// Type coercion is performed for comparisons... -"5" == 5 // = true +// Type coercion is performed for comparisons with double equals... +"5" == 5; // = true +null == undefined; // = true // ...unless you use === -"5" === 5 // = false +"5" === 5; // = false +null === undefined; // = false -// You can access characters in a string with charAt -"This is a string".charAt(0) +// ...which can result in some weird behaviour... +13 + !0; // 14 +"13" + !0; // '13true' -// There's also null and undefined -null // used to indicate a deliberate non-value -undefined // used to indicate a value that hasn't been set yet +// You can access characters in a string with `charAt` +"This is a string".charAt(0); // = 'T' -// null, undefined, NaN, 0 and "" are falsy, and everything else is truthy. +// ...or use `substring` to get larger pieces. +"Hello world".substring(0, 5); // = "Hello" + +// `length` is a property, so don't use (). +"Hello".length; // = 5 + +// There's also `null` and `undefined`. +null; // used to indicate a deliberate non-value +undefined; // used to indicate a value is not currently present (although + // `undefined` is actually a value itself) + +// false, null, undefined, NaN, 0 and "" are falsy; everything else is truthy. // Note that 0 is falsy and "0" is truthy, even though 0 == "0". /////////////////////////////////// // 2. Variables, Arrays and Objects -// Variables are declared with the var keyword. Javascript is dynamically typed, -// so you don't need to specify type. Assignment uses a single = character. -var someVar = 5 +// Variables are declared with the `var` keyword. JavaScript is dynamically +// typed, so you don't need to specify type. Assignment uses a single `=` +// character. +var someVar = 5; // if you leave the var keyword off, you won't get an error... -someOtherVar = 10 +someOtherVar = 10; // ...but your variable will be created in the global scope, not in the scope // you defined it in. // Variables declared without being assigned to are set to undefined. -var someThirdVar // = undefined +var someThirdVar; // = undefined // There's shorthand for performing math operations on variables: -someVar += 5 // equivalent to someVar = someVar + 5; someVar is 10 now -someVar *= 10 // now someVar is 100 +someVar += 5; // equivalent to someVar = someVar + 5; someVar is 10 now +someVar *= 10; // now someVar is 100 // and an even-shorter-hand for adding or subtracting 1 -someVar++ // now someVar is 101 -someVar-- // back to 100 +someVar++; // now someVar is 101 +someVar--; // back to 100 // Arrays are ordered lists of values, of any type. -var myArray = ["Hello", 45, true] +var myArray = ["Hello", 45, true]; // Their members can be accessed using the square-brackets subscript syntax. // Array indices start at zero. -myArray[1] // = 45 +myArray[1]; // = 45 + +// Arrays are mutable and of variable length. +myArray.push("World"); +myArray.length; // = 4 + +// Add/Modify at specific index +myArray[3] = "Hello"; -// JavaScript's objects are equivalent to 'dictionaries' or 'maps' in other +// JavaScript's objects are equivalent to "dictionaries" or "maps" in other // languages: an unordered collection of key-value pairs. -{key1: "Hello", key2: "World"} +var myObj = {key1: "Hello", key2: "World"}; // Keys are strings, but quotes aren't required if they're a valid // JavaScript identifier. Values can be any type. -var myObj = {myKey: "myValue", "my other key": 4} +var myObj = {myKey: "myValue", "my other key": 4}; // Object attributes can also be accessed using the subscript syntax, -myObj["my other key"] // = 4 +myObj["my other key"]; // = 4 // ... or using the dot syntax, provided the key is a valid identifier. -myObj.myKey // = "myValue" +myObj.myKey; // = "myValue" // Objects are mutable; values can be changed and new keys added. -myObj.myThirdKey = true +myObj.myThirdKey = true; // If you try to access a value that's not yet set, you'll get undefined. -myObj.myFourthKey // = undefined +myObj.myFourthKey; // = undefined /////////////////////////////////// // 3. Logic and Control Structures -// The if structure works as you'd expect. -var count = 1 +// The syntax for this section is almost identical to Java's. + +// The `if` structure works as you'd expect. +var count = 1; if (count == 3){ // evaluated if count is 3 -} else if (count == 4) { +} else if (count == 4){ // evaluated if count is 4 } else { // evaluated if it's not either 3 or 4 } -// As does while. -while (true) { +// As does `while`. +while (true){ // An infinite loop! } // Do-while loops are like while loops, except they always run at least once. -var input +var input; do { - input = getInput() + input = getInput(); } while (!isValid(input)) -// the for loop is the same as C and Java: +// The `for` loop is the same as C and Java: // initialisation; continue condition; iteration. for (var i = 0; i < 5; i++){ // will run 5 times @@ -192,29 +220,56 @@ for (var i = 0; i < 5; i++){ // && is logical and, || is logical or if (house.size == "big" && house.colour == "blue"){ - house.contains = "bear" + house.contains = "bear"; } if (colour == "red" || colour == "blue"){ // colour is either red or blue } // && and || "short circuit", which is useful for setting default values. -var name = otherName || "default" +var name = otherName || "default"; + + +// The `switch` statement checks for equality with `===`. +// use 'break' after each case +// or the cases after the correct one will be executed too. +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. Functions, Scope and Closures -// JavaScript functions are declared with the function keyword. +// JavaScript functions are declared with the `function` keyword. function myFunction(thing){ - return thing.toUpperCase() + return thing.toUpperCase(); } -myFunction("foo") // = "FOO" - -// Functions can also be defined "anonymously" - without a name: -function(thing){ - return thing.toLowerCase() +myFunction("foo"); // = "FOO" + +// Note that the value to be returned must start on the same line as the +// `return` keyword, otherwise you'll always return `undefined` due to +// automatic semicolon insertion. Watch out for this when using Allman style. +function myFunction() +{ + return // <- semicolon automatically inserted here + { + thisIsAn: 'object literal' + } } -// (we can't call our function, since we don't have a name to refer to it with) +myFunction(); // = undefined // JavaScript functions are first class objects, so they can be reassigned to // different variable names and passed to other functions as arguments - for @@ -222,52 +277,53 @@ function(thing){ function myFunction(){ // this code will be called in 5 seconds' time } -setTimeout(myFunction, 5000) - -// You can even write the function statement directly in the call to the other -// function. +setTimeout(myFunction, 5000); +// Note: setTimeout isn't part of the JS language, but is provided by browsers +// and Node.js. -setTimeout(function myFunction(){ +// Function objects don't even have to be declared with a name - you can write +// an anonymous function definition directly into the arguments of another. +setTimeout(function(){ // this code will be called in 5 seconds' time -}, 5000) +}, 5000); // JavaScript has function scope; functions get their own scope but other blocks // do not. if (true){ - var i = 5 + var i = 5; } -i // = 5 - not undefined as you'd expect in a block-scoped language +i; // = 5 - not undefined as you'd expect in a block-scoped language // This has led to a common pattern of "immediately-executing anonymous // functions", which prevent temporary variables from leaking into the global // scope. -function(){ - var temporary = 5 - // We can access the global scope by assiging to the 'global object', which - // in a web browser is always 'window'. The global object may have a +(function(){ + var temporary = 5; + // We can access the global scope by assiging to the "global object", which + // in a web browser is always `window`. The global object may have a // different name in non-browser environments such as Node.js. - window.permanent = 10 - // Or, as previously mentioned, we can just leave the var keyword off. - permanent2 = 15 -}() -temporary // raises ReferenceError -permanent // = 10 -permanent2 // = 15 + window.permanent = 10; +})(); +temporary; // raises ReferenceError +permanent; // = 10 // One of JavaScript's most powerful features is closures. If a function is // defined inside another function, the inner function has access to all the -// outer function's variables. +// outer function's variables, even after the outer function exits. function sayHelloInFiveSeconds(name){ - var prompt = "Hello, " + name + "!" + var prompt = "Hello, " + name + "!"; + // Inner functions are put in the local scope by default, as if they were + // declared with `var`. function inner(){ - alert(prompt) + alert(prompt); } - setTimeout(inner, 5000) - // setTimeout is asynchronous, so this function will finish without waiting - // 5 seconds. However, once the 5 seconds is up, inner will still have - // access to the value of prompt. + setTimeout(inner, 5000); + // setTimeout is asynchronous, so the sayHelloInFiveSeconds function will + // exit immediately, and setTimeout will call inner afterwards. However, + // because inner is "closed over" sayHelloInFiveSeconds, inner still has + // access to the `prompt` variable when it is finally called. } -sayHelloInFiveSeconds("Adam") // will open a popup with "Hello, Adam!" in 5s +sayHelloInFiveSeconds("Adam"); // will open a popup with "Hello, Adam!" in 5s /////////////////////////////////// // 5. More about Objects; Constructors and Prototypes @@ -275,124 +331,157 @@ sayHelloInFiveSeconds("Adam") // will open a popup with "Hello, Adam!" in 5s // Objects can contain functions. var myObj = { myFunc: function(){ - return "Hello world!" + return "Hello world!"; } -} -myObj.myFunc() // = "Hello world!" +}; +myObj.myFunc(); // = "Hello world!" // When functions attached to an object are called, they can access the object -// they're attached to using the this keyword. +// they're attached to using the `this` keyword. myObj = { myString: "Hello world!", myFunc: function(){ - return this.myString + return this.myString; } -} -myObj.myFunc() // = "Hello world!" +}; +myObj.myFunc(); // = "Hello world!" // What this is set to has to do with how the function is called, not where // it's defined. So, our function doesn't work if it isn't called in the // context of the object. -var myFunc = myObj.myFunc -myFunc() // = undefined +var myFunc = myObj.myFunc; +myFunc(); // = undefined // Inversely, a function can be assigned to the object and gain access to it -// through this, even if it wasn't attached when it was defined. +// through `this`, even if it wasn't attached when it was defined. var myOtherFunc = function(){ - return this.myString.toUpperCase() + return this.myString.toUpperCase(); } -myObj.myOtherFunc = myOtherFunc -myObj.myOtherFunc() // = "HELLO WORLD!" +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "HELLO WORLD!" + +// We can also specify a context for a function to execute in when we invoke it +// using `call` or `apply`. + +var anotherFunc = function(s){ + return this.myString + s; +} +anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!" + +// The `apply` function is nearly identical, but takes an array for an argument +// list. -// When you call a function with the new keyword, a new object is created, and -// made available to the function via this. Functions designed to be called -// like this are called constructors. +anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!" + +// This is useful when working with a function that accepts a sequence of +// arguments and you want to pass an array. + +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// But, `call` and `apply` are only temporary. When we want it to stick, we can +// use `bind`. + +var boundFunc = anotherFunc.bind(myObj); +boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!" + +// `bind` can also be used to partially apply (curry) a function. + +var product = function(a, b){ return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// When you call a function with the `new` keyword, a new object is created, and +// made available to the function via the this keyword. Functions designed to be +// called like that are called constructors. var MyConstructor = function(){ - this.myNumber = 5 + this.myNumber = 5; } -myNewObj = new MyConstructor() // = {myNumber: 5} -myNewObj.myNumber // = 5 +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 // Every JavaScript object has a 'prototype'. When you go to access a property // on an object that doesn't exist on the actual object, the interpreter will // look at its prototype. // Some JS implementations let you access an object's prototype on the magic -// property __proto__. While this is useful for explaining prototypes it's not +// property `__proto__`. While this is useful for explaining prototypes it's not // part of the standard; we'll get to standard ways of using prototypes later. var myObj = { - myString: "Hello world!", -} + myString: "Hello world!" +}; var myPrototype = { meaningOfLife: 42, myFunc: function(){ return this.myString.toLowerCase() } -} -myObj.__proto__ = myPrototype -myObj.meaningOfLife // = 42 +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 // This works for functions, too. -myObj.myFunc() // = "hello world!" +myObj.myFunc(); // = "hello world!" // Of course, if your property isn't on your prototype, the prototype's // prototype is searched, and so on. myPrototype.__proto__ = { myBoolean: true -} -myObj.myBoolean // = true +}; +myObj.myBoolean; // = true // There's no copying involved here; each object stores a reference to its // prototype. This means we can alter the prototype and our changes will be // reflected everywhere. -myPrototype.meaningOfLife = 43 -myObj.meaningOfLife // = 43 +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 -// We mentioned that __proto__ was non-standard, and there's no standard way to -// change the prototype of an existing object. However, there's two ways to +// We mentioned that `__proto__` was non-standard, and there's no standard way to +// change the prototype of an existing object. However, there are two ways to // create a new object with a given prototype. // The first is Object.create, which is a recent addition to JS, and therefore // not available in all implementations yet. -var myObj = Object.create(myPrototype) -myObj.meaningOfLife // = 43 +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 // The second way, which works anywhere, has to do with constructors. // Constructors have a property called prototype. This is *not* the prototype of // the constructor function itself; instead, it's the prototype that new objects // are given when they're created with that constructor and the new keyword. -myConstructor.prototype = { +MyConstructor.prototype = { + myNumber: 5, getMyNumber: function(){ - return this.myNumber + return this.myNumber; } -} -var myNewObj2 = new myConstructor() -myNewObj2.getMyNumber() // = 5 +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 // Built-in types like strings and numbers also have constructors that create // equivalent wrapper objects. -var myNumber = 12 -var myNumberObj = new Number(12) -myNumber == myNumberObj // = true +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true // Except, they aren't exactly equivalent. -typeof(myNumber) // = 'number' -typeof(myNumberObj) // = 'object' -myNumber === myNumberObj // = false +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false if (0){ // This code won't execute, because 0 is falsy. } -if (Number(0)){ - // This code *will* execute, because Number(0) is truthy. -} // However, the wrapper objects and the regular builtins share a prototype, so // you can actually add functionality to a string, for instance. String.prototype.firstCharacter = function(){ - return this.charAt(0) + return this.charAt(0); } -"abc".firstCharacter() // = "a" +"abc".firstCharacter(); // = "a" // This fact is often used in "polyfilling", which is implementing newer // features of JavaScript in an older subset of JavaScript, so that they can be @@ -403,10 +492,10 @@ String.prototype.firstCharacter = function(){ if (Object.create === undefined){ // don't overwrite it if it exists Object.create = function(proto){ // make a temporary constructor with the right prototype - var Constructor = function(){} - Constructor.prototype = proto + var Constructor = function(){}; + Constructor.prototype = proto; // then use it to create a new, appropriately-prototyped object - return new Constructor() + return new Constructor(); } } ``` @@ -427,9 +516,13 @@ more about how to use JavaScript in web pages, start by learning about the [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) -[Javascript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth +[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth guide of all the counter-intuitive parts of the language. +[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book. + In addition to direct contributors to this article, some content is adapted from Louie Dinh's Python tutorial on this site, and the [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) diff --git a/json.html.markdown b/json.html.markdown new file mode 100644 index 00000000..6aff2ce2 --- /dev/null +++ b/json.html.markdown @@ -0,0 +1,58 @@ +--- +language: json +filename: learnjson.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +--- + +As JSON is an extremely simple data-interchange format, this is most likely going +to be the simplest Learn X in Y Minutes ever. + +JSON in its purest form has no actual comments, but most parsers will accept +C-style (`//`, `/* */`) comments. For the purposes of this, however, everything is +going to be 100% valid JSON. Luckily, it kind of speaks for itself. + +```json +{ + "key": "value", + + "keys": "must always be enclosed in double quotes", + "numbers": 0, + "strings": "Hellø, wørld. All unicode is allowed, along with \"escaping\".", + "has bools?": true, + "nothingness": null, + + "big number": 1.2e+100, + + "objects": { + "comment": "Most of your structure will come from objects.", + + "array": [0, 1, 2, 3, "Arrays can have anything in them.", 5], + + "another object": { + "comment": "These things can be nested, very useful." + } + }, + + "silliness": [ + { + "sources of potassium": ["bananas"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "alternative style": { + "comment": "check this out!" + , "comma position": "doesn't matter - as long as it's before the value, then it's valid" + , "another comment": "how nice" + }, + + "that was short": "And, you're done. You now know everything JSON has to offer." +} +``` diff --git a/julia.html.markdown b/julia.html.markdown index 1023e303..66329feb 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -1,5 +1,5 @@ --- -language: julia +language: Julia contributors: - ["Leah Hanson", "http://leahhanson.us"] filename: learnjulia.jl @@ -8,11 +8,15 @@ filename: learnjulia.jl Julia is a new homoiconic functional language focused on technical computing. While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python. -This is based on the current development version of Julia, as of June 29th, 2013. +This is based on Julia 0.3. ```ruby -# Single line comments start with a hash. +# Single line comments start with a hash (pound) symbol. +#= Multiline comments can be written + by putting '#=' before the text and '=#' + after the text. They can also be nested. +=# #################################################### ## 1. Primitive Datatypes and Operators @@ -20,105 +24,110 @@ This is based on the current development version of Julia, as of June 29th, 2013 # Everything in Julia is a expression. -# You have numbers -3 #=> 3 (Int64) -3.2 #=> 3.2 (Float64) -2 + 1im #=> 2 + 1im (Complex{Int64}) -2//3 #=> 2//3 (Rational{Int64}) - -# Math is what you would expect -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 -35 / 5 #=> 7.0 -5 \ 35 #=> 7.0 -5 / 2 #=> 2.5 -div(5, 2) #=> 2 -2 ^ 2 #=> 4 # power, not bitwise xor -12 % 10 #=> 2 +# There are several basic types of numbers. +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# All of the normal infix operators are available. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float +div(5, 2) # => 2 # for a truncated result, use div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # power, not bitwise xor +12 % 10 # => 2 # Enforce precedence with parentheses -(1 + 3) * 2 #=> 8 +(1 + 3) * 2 # => 8 # Bitwise Operators -~2 #=> -3 # bitwise not -3 & 5 #=> 1 # bitwise and -2 | 4 #=> 6 # bitwise or -2 $ 4 #=> 6 # bitwise xor -2 >>> 1 #=> 1 # logical shift right -2 >> 1 #=> 1 # arithmetic shift right -2 << 1 #=> 4 # logical/arithmetic shift left +~2 # => -3 # bitwise not +3 & 5 # => 1 # bitwise and +2 | 4 # => 6 # bitwise or +2 $ 4 # => 6 # bitwise xor +2 >>> 1 # => 1 # logical shift right +2 >> 1 # => 1 # arithmetic shift right +2 << 1 # => 4 # logical/arithmetic shift left # You can use the bits function to see the binary representation of a number. bits(12345) -#=> "0000000000000000000000000000000000000000000000000011000000111001" +# => "0000000000000000000000000000000000000000000000000011000000111001" bits(12345.0) -#=> "0100000011001000000111001000000000000000000000000000000000000000" +# => "0100000011001000000111001000000000000000000000000000000000000000" # Boolean values are primitives true false # Boolean operators -!true #=> false -!false #=> true -1 == 1 #=> true -2 == 1 #=> false -1 != 1 #=> false -2 != 1 #=> true -1 < 10 #=> true -1 > 10 #=> false -2 <= 2 #=> true -2 >= 2 #=> true +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true # Comparisons can be chained -1 < 2 < 3 #=> true -2 < 3 < 2 #=> false +1 < 2 < 3 # => true +2 < 3 < 2 # => false # Strings are created with " "This is a string." -# Character literals written with ' +# Character literals are written with ' 'a' -# A string can be treated like a list of characters -"This is a string"[1] #=> 'T' # Julia indexes from 1 +# A string can be indexed like an array of characters +"This is a string"[1] # => 'T' # Julia indexes from 1 +# However, this is will not work well for UTF8 strings, +# so iterating over strings is recommended (map, for loops, etc). # $ can be used for string interpolation: -"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" -# You can put any Julia expression inside the parenthesis. +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# You can put any Julia expression inside the parentheses. # Another way to format strings is the printf macro. @printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 +# Printing is easy +println("I'm Julia. Nice to meet you!") + #################################################### ## 2. Variables and Collections #################################################### -# Printing is pretty easy -println("I'm Julia. Nice to meet you!") - -# No need to declare variables before assigning to them. -some_var = 5 #=> 5 -some_var #=> 5 +# You don't declare variables before assigning to them. +some_var = 5 # => 5 +some_var # => 5 # Accessing a previously unassigned variable is an error try - some_other_var #=> ERROR: some_other_var not defined + some_other_var # => ERROR: some_other_var not defined catch e println(e) end -# Variable name start with a letter. You can use uppercase letters, digits, -# and exclamation points as well after the initial alphabetic character. -SomeOtherVar123! = 6 #=> 6 +# Variable names start with a letter. +# After that, you can use letters, digits, underscores, and exclamation points. +SomeOtherVar123! = 6 # => 6 # You can also use unicode characters -☃ = 8 #=> 8 +☃ = 8 # => 8 +# These are especially handy for mathematical notation +2 * π # => 6.283185307179586 # A note on naming conventions in Julia: # -# * Names of variables are in lower case, with word separation indicated by -# underscores ('\_'). +# * Word separation can be indicated by underscores ('_'), but use of +# underscores is discouraged unless the name would be hard to read +# otherwise. # # * Names of Types begin with a capital letter and word separation is shown # with CamelCase instead of underscores. @@ -129,45 +138,49 @@ SomeOtherVar123! = 6 #=> 6 # functions are sometimes called mutating functions or in-place functions. # Arrays store a sequence of values indexed by integers 1 through n: -a = Int64[] #=> 0-element Int64 Array +a = Int64[] # => 0-element Int64 Array # 1-dimensional array literals can be written with comma-separated values. -b = [4, 5, 6] #=> 3-element Int64 Array: [4, 5, 6] -b[1] #=> 4 -b[end] #=> 6 +b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 # 2-dimentional arrays use space-separated values and semicolon-separated rows. -matrix = [1 2; 3 4] #=> 2x2 Int64 Array: [1 2; 3 4] +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] # Add stuff to the end of a list with push! and append! -push!(a,1) #=> [1] -push!(a,2) #=> [1,2] -push!(a,4) #=> [1,2,4] -push!(a,3) #=> [1,2,4,3] -append!(a,b) #=> [1,2,4,3,4,5,6] +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] # Remove from the end with pop -pop!(a) #=> 6 and b is now [4,5] +pop!(b) # => 6 and b is now [4,5] # Let's put it back push!(b,6) # b is now [4,5,6] again. -a[1] #=> 1 # remember that Julia indexes from 1, not 0! +a[1] # => 1 # remember that Julia indexes from 1, not 0! # end is a shorthand for the last index. It can be used in any # indexing expression -a[end] #=> 6 +a[end] # => 6 + +# we also have shift and unshift +shift!(a) # => 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] # Function names that end in exclamations points indicate that they modify # their argument. -arr = [5,4,6] #=> 3-element Int64 Array: [5,4,6] -sort(arr) #=> [4,5,6]; arr is still [5,4,6] -sort!(arr) #=> [4,5,6]; arr is now [4,5,6] +arr = [5,4,6] # => 3-element Int64 Array: [5,4,6] +sort(arr) # => [4,5,6]; arr is still [5,4,6] +sort!(arr) # => [4,5,6]; arr is now [4,5,6] # Looking out of bounds is a BoundsError try - a[0] #=> ERROR: BoundsError() in getindex at array.jl:270 - a[end+1] #=> ERROR: BoundsError() in getindex at array.jl:270 + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 catch e println(e) end @@ -177,105 +190,109 @@ end # inside the julia folder to find these files. # You can initialize arrays from ranges -a = [1:5] #=> 5-element Int64 Array: [1,2,3,4,5] +a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5] # You can look at ranges with slice syntax. -a[1:3] #=> [1, 2, 3] -a[2:] #=> [2, 3, 4, 5] +a[1:3] # => [1, 2, 3] +a[2:end] # => [2, 3, 4, 5] -# Remove arbitrary elements from a list with splice! +# Remove elements from an array by index with splice! arr = [3,4,5] -splice!(arr,2) #=> 4 ; arr is now [3,5] +splice!(arr,2) # => 4 ; arr is now [3,5] # Concatenate lists with append! b = [1,2,3] -append!(a,b) # Now a is [1, 3, 4, 5, 1, 2, 3] +append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3] -# Check for existence in a list with contains -contains(a,1) #=> true +# Check for existence in a list with in +in(1, a) # => true # Examine the length with length -length(a) #=> 7 +length(a) # => 8 # Tuples are immutable. -tup = (1, 2, 3) #=>(1,2,3) # an (Int64,Int64,Int64) tuple. -tup[1] #=> 1 +tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. +tup[1] # => 1 try: - tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) catch e println(e) end # Many list functions also work on tuples -length(tup) #=> 3 -tup[1:2] #=> (1,2) -contains(tup,2) #=> true +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true # You can unpack tuples into variables -a, b, c = (1, 2, 3) #=> (1,2,3) # a is now 1, b is now 2 and c is now 3 +a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3 + +# Tuples are created even if you leave out the parentheses +d, e, f = 4, 5, 6 # => (4,5,6) -# Tuples are created by default if you leave out the parentheses -d, e, f = 4, 5, 6 #=> (4,5,6) +# A 1-element tuple is distinct from the value it contains +(1,) == 1 # => false +(1) == 1 # => true -# Now look how easy it is to swap two values -e, d = d, e #=> (5,4) # d is now 5 and e is now 4 +# Look how easy it is to swap two values +e, d = d, e # => (5,4) # d is now 5 and e is now 4 # Dictionaries store mappings -empty_dict = Dict() #=> Dict{Any,Any}() +empty_dict = Dict() # => Dict{Any,Any}() -# Here is a prefilled dictionary +# You can create a dictionary using a literal filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] # => Dict{ASCIIString,Int64} # Look up values with [] -filled_dict["one"] #=> 1 +filled_dict["one"] # => 1 # Get all keys keys(filled_dict) -#=> KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) # Note - dictionary keys are not sorted or in the order you inserted them. -# Get all values +# Get all values values(filled_dict) -#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) # Note - Same as above regarding key ordering. -# Check for existence of keys in a dictionary with contains, haskey -contains(filled_dict, ("one", 1)) #=> true -contains(filled_dict, ("two", 3)) #=> false -haskey(filled_dict, "one") #=> true -haskey(filled_dict, 1) #=> false +# Check for existence of keys in a dictionary with in, haskey +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false -# Trying to look up a non-existing key will raise an error +# Trying to look up a non-existent key will raise an error try - filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489 + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 catch e println(e) end -# Use get method to avoid the error +# Use the get method to avoid that error by providing a default value # get(dictionary,key,default_value) -get(filled_dict,"one",4) #=> 1 -get(filled_dict,"four",4) #=> 4 +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 -# Sets store sets -empty_set = Set() #=> Set{Any}() -# Initialize a set with a bunch of values -filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) +# Use Sets to represent collections of unordered, unique values +empty_set = Set() # => Set{Any}() +# Initialize a set with values +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) -# Add more items to a set -add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) +# Add more values to a set +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) -# There are functions for set intersection, union, and difference. -other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3) -intersect(filled_set, other_set) #=> Set{Int64}(3,4,5) -union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6) -setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4) +# Check if the values are in the set +in(2, filled_set) # => true +in(10, filled_set) # => false -# Check for existence in a set with contains -contains(filled_set,2) #=> true -contains(filled_set,10) #=> false +# There are functions for set intersection, union, and difference. +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) #################################################### @@ -285,8 +302,7 @@ contains(filled_set,10) #=> false # Let's make a variable some_var = 5 -# Here is an if statement. Indentation is NOT meaningful in Julia. -# prints "some var is smaller than 10" +# Here is an if statement. Indentation is not meaningful in Julia. if some_var > 10 println("some_var is totally bigger than 10.") elseif some_var < 10 # This elseif clause is optional. @@ -294,85 +310,103 @@ elseif some_var < 10 # This elseif clause is optional. else # The else clause is optional too. println("some_var is indeed 10.") end +# => prints "some var is smaller than 10" -# For loops iterate over iterables, such as ranges, lists, sets, dicts, strings. - +# For loops iterate over iterables. +# Iterable types include Range, Array, Set, Dict, and String. for animal=["dog", "cat", "mouse"] - # You can use $ to interpolate into strings println("$animal is a mammal") + # You can use $ to interpolate variables or expression into strings end # prints: # dog is a mammal # cat is a mammal # mouse is a mammal -# You can use in instead of =, if you want. +# You can use 'in' instead of '='. for animal in ["dog", "cat", "mouse"] println("$animal is a mammal") end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] - println("$(a[1]) is $(a[2])") + println("$(a[1]) is a $(a[2])") end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] - println("$k is $v") + println("$k is a $v") end - - -# While loops go until a condition is no longer met. # prints: -# 0 -# 1 -# 2 -# 3 +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# While loops loop while a condition is true x = 0 while x < 4 println(x) x += 1 # Shorthand for x = x + 1 end +# prints: +# 0 +# 1 +# 2 +# 3 -# Handle exceptions with a try/except block +# Handle exceptions with a try/catch block try error("help") catch e println("caught it $e") end -#=> caught it ErrorException("help") +# => caught it ErrorException("help") #################################################### ## 4. Functions #################################################### -# Use the keyword function to create new functions +# The keyword 'function' creates new functions +#function name(arglist) +# body... +#end function add(x, y) println("x is $x and y is $y") - # Functions implicitly return the value of their last statement + # Functions return the value of their last statement x + y end -add(5, 6) #=> 11 after printing out "x is 5 and y is 6" +add(5, 6) # => 11 after printing out "x is 5 and y is 6" # You can define functions that take a variable number of # positional arguments function varargs(args...) return args + # use the keyword return to return anywhere in the function end +# => varargs (generic function with 1 method) -varargs(1,2,3) #=> (1,2,3) +varargs(1,2,3) # => (1,2,3) # The ... is called a splat. -# It can also be used in a fuction call -# to splat a list or tuple out to be the arguments -Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays -Set([1,2,3]...) #=> Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3) +# We just used it in a function definition. +# It can also be used in a fuction call, +# where it will splat an Array or Tuple's contents into the argument list. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays +Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3) -x = (1,2,3) #=> (1,2,3) -Set(x) #=> Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples -Set(x...) #=> Set{Int64}(2,3,1) +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples +Set(x...) # => Set{Int64}(2,3,1) # You can define functions with optional positional arguments @@ -380,26 +414,26 @@ function defaults(a,b,x=5,y=6) return "$a $b and $x $y" end -defaults('h','g') #=> "h g and 5 6" -defaults('h','g','j') #=> "h g and j 6" -defaults('h','g','j','k') #=> "h g and j k" +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" try - defaults('h') #=> ERROR: no method defaults(Char,) - defaults() #=> ERROR: no methods defaults() + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() catch e -println(e) + println(e) end # You can define functions that take keyword arguments function keyword_args(;k1=4,name2="hello") # note the ; return ["k1"=>k1,"name2"=>name2] -end +end -keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] -keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] -keyword_args() #=> ["name2"=>"hello","k2"=>4] +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] -# You can also do both at once +# You can combine all kinds of arguments in the same function function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") println("normal arg: $normal_arg") println("optional arg: $optional_positional_arg") @@ -420,12 +454,15 @@ function create_adder(x) return adder end -# or equivalently +# This is "stabby lambda syntax" for creating anonymous functions +(x -> x > 2)(3) # => true + +# This function is identical to create_adder implementation above. function create_adder(x) y -> x + y end -# you can also name the internal function, if you want +# You can also name the internal function, if you want function create_adder(x) function adder(y) x + y @@ -434,92 +471,277 @@ function create_adder(x) end add_10 = create_adder(10) -add_10(3) #=> 13 +add_10(3) # => 13 -# The first two inner functions above are anonymous functions -(x -> x > 2)(3) #=> true # There are built-in higher order functions -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] -# We can use list comprehensions for nice maps and filters -[add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13] -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +# We can use list comprehensions for nicer maps +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] #################################################### -## 5. Types and Multiple-Dispatch +## 5. Types #################################################### -# Type definition +# Julia has a type system. +# Every value has a type; variables do not have types themselves. +# You can use the `typeof` function to get the type of a value. +typeof(5) # => Int64 + +# Types are first-class values +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType is the type that represents types, including itself. + +# Types are used for documentation, optimizations, and dispatch. +# They are not statically checked. + +# Users can define types +# They are like records or structs in other languages. +# New types are defined using the `type` keyword. + +# type Name +# field::OptionalType +# ... +# end type Tiger taillength::Float64 - coatcolor # no type annotation is implicitly Any + coatcolor # not including a type annotation is the same as `::Any` end -# default constructor is the properties in order -# so, Tiger(taillength,coatcolor) -# Type instantiation -tigger = Tiger(3.5,"orange") # the type doubles as the constructor function +# The default constructor's arguments are the properties +# of the type, in the order they are listed in the definition +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") -# Abtract Types -abstract Cat # just a name and point in the type hierarchy +# The type doubles as the constructor function for values of that type +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") -# * types defined with the type keyword are concrete types; they can be -# instantiated -# -# * types defined with the abstract keyword are abstract types; they can -# have subtypes. -# -# * each type has one supertype; a supertype can have zero or more subtypes. +# These struct-style types are called concrete types +# They can be instantiated, but cannot have subtypes. +# The other kind of types is abstract types. +# abstract Name +abstract Cat # just a name and point in the type hierarchy + +# Abstract types cannot be instantiated, but can have subtypes. +# For example, Number is an abstract type +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# Every type has a super type; use the `super` function to get it. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# All of these type, except for Int64, are abstract. + +# <: is the subtyping operator type Lion <: Cat # Lion is a subtype of Cat mane_color roar::String end +# You can define more constructors for your type +# Just define a function of the same name as the type +# and call an existing constructor to get a value of the correct type +Lion(roar::String) = Lion("green",roar) +# This is an outer constructor because it's outside the type definition + type Panther <: Cat # Panther is also a subtype of Cat eye_color Panther() = new("green") # Panthers will only have this constructor, and no default constructor. end +# Using inner constructors, like Panther does, gives you control +# over how values of the type can be created. +# When possible, you should use outer constructors rather than inner ones. -# Multiple Dispatch +#################################################### +## 6. Multiple-Dispatch +#################################################### # In Julia, all named functions are generic functions # This means that they are built up from many small methods -# For example, let's make a function meow: -function meow(cat::Lion) - cat.roar # access properties using dot notation +# Each constructor for Lion is a method of the generic function Lion. + +# For a non-constructor example, let's make a function meow: + +# Definitions for Lion, Panther, Tiger +function meow(animal::Lion) + animal.roar # access type properties using dot notation end -function meow(cat::Panther) +function meow(animal::Panther) "grrr" end -function meow(cat::Tiger) +function meow(animal::Tiger) "rawwwr" end -meow(tigger) #=> "rawwr" -meow(Lion("brown","ROAAR")) #=> "ROAAR" -meow(Panther()) #=> "grrr" +# Testing the meow function +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" +# Review the local type hierarchy +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# Defining a function that takes Cats function pet_cat(cat::Cat) println("The cat says $(meow(cat))") end +pet_cat(Lion("42")) # => prints "The cat says 42" try - pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,) + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) catch e println(e) end -pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42" +# In OO languages, single dispatch is common; +# this means that the method is picked based on the type of the first argument. +# In Julia, all of the argument types contribute to selecting the best method. + +# Let's define a function with more arguments, so we can see the difference +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The orange tiger wins! + +# Let's change the behavior when the Cat is specifically a Lion +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins! + +# We don't need a Tiger in order to fight +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end +# Also let the cat go first +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# This warning is because it's unclear which fight will be called in: +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr +# The result may be different in other versions of Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie + + +# Under the hood +# You can take a look at the llvm and the assembly code generated. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# What happens when we feed square_area an integer? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prologue + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # Fetch l from memory? + # imul RAX, RAX # Square l and store the result in RAX + # pop RBP # Restore old base pointer + # ret # Result will still be in RAX + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX) + # pop RBP + # ret + # +# Note that julia will use floating point instructions if any of the +# arguements are floats. +# Let's calculate the area of a circle +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory + # movabs RAX, 4593140240 # Load pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # ``` ## Further Reading You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/) +The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users). diff --git a/ko-kr/brainfuck-kr.html.markdown b/ko-kr/brainfuck-kr.html.markdown new file mode 100644 index 00000000..c2e4341f --- /dev/null +++ b/ko-kr/brainfuck-kr.html.markdown @@ -0,0 +1,84 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["JongChan Choi", "http://0xABCDEF.com/"] + - ["Peter Lee", "http://peterjlee.com/"] +lang: ko-kr +--- + +Brainfuck(문장을 시작하는 단어가 아닌이상 첫글자는 대문자를 사용하지 않습니다)은 +여덟가지 명령어만으로 튜링-완전한 최소주의 프로그래밍 언어입니다. + +``` +"><+-.,[]" 이외의 문자들은 무시됩니다. (쌍따옴표는 제외) + +브레인퍽은 30,000 칸 짜리의 0으로 초기화된 배열과, +현재 칸을 가르키는 포인터로 표현됩니다. + +여덟가지의 명령어는 다음과 같습니다: ++ : 포인터가 가르키는 현재 칸의 값을 1 증가시킵니다. +- : 포인터가 가르키는 현재 칸의 값을 1 감소시킵니다. +> : 포인터가 다음 칸(오른쪽 칸)을 가르키도록 이동시킵니다. +< : 포인터가 이전 칸(왼쪽 칸)을 가르키도록 이동시킵니다. +. : 현재 칸의 값을 ASCII 문자로 출력합니다. (즉, 65 = 'A') +, : 하나의 문자를 입력받고 그 값을 현재 칸에 대입합니다. +[ : 현재 칸의 값이 0이면 짝이 맞는 ] 명령으로 넘어갑니다. + 0이 아니면 다음 명령어로 넘어갑니다. +] : 현재 칸의 값이 0이면 다음 명령어로 넘어갑니다. + 0이 아니면 짝이 맞는 [ 명령으로 다시 돌아갑니다. + +[이랑 ]은 while 루프를 만들어냅니다. 무조건, 짝이 맞아야 합니다. + +몇가지 간단한 브레인퍽 프로그램을 보겠습니다. + +++++++ [ > ++++++++++ < - ] > +++++ . + +이 프로그램은 문자 'A'를 출력합니다. 처음에는, 반복할 횟수를 정하기 위한 값을 +만들기 위해 첫번째 칸의 값을 6으로 증가시킵니다. 그리고 루프로 들어가서([) +두번째 칸으로 넘어갑니다. 루프 안에서는 두번째 칸의 값을 10 증가시키고, +다시 첫번째 칸으로 넘어가서 값을 1 감소시킵니다. 이 루프는 여섯번 돕니다. +(첫번째 칸의 값을 6번 감소시켜서 0이 될 때 까지는 ] 명령을 만날 때마다 +루프의 시작 지점으로 돌아갑니다) + +이 시점에서, 두번째 칸의 값은 60이고, 포인터는 값이 0인 첫번째 칸에 위치합니다. +여기서 두번째 칸으로 넘어간 다음 값을 5 증가시키면 두번째 칸의 값이 65가 되고, +65는 문자 'A'에 대응하는 아스키 코드이기 때문에, 두번째 칸의 값을 출력하면 +터미널에 'A'가 출력됩니다. + +, [ > + < - ] > . + +이 프로그램은 사용자로부터 문자 하나를 입력받아 첫번째 칸에 집어넣습니다. +그리고 루프에 들어가서, 두번째 칸으로 넘어가 값을 한 번 증가시킨 다음, +다시 첫번째 칸으로 넘어가서 값을 한 번 감소시킵니다. +이는 첫번째 칸의 값이 0이 될 때까지 지속되며, +두번째 칸은 첫번째 칸이 갖고있던 값을 가지게 됩니다. +루프가 종료되면 포인터는 첫번째 칸을 가르키기 때문에 두번째 칸으로 넘어가고, +해당 아스키 코드에 대응하는 문자를 출력합니다. + +또한 공백문자는 순전히 가독성을 위해서 작성되었다는 것을 기억하세요. +다음과 같이 작성해도 똑같이 돌아갑니다: + +,[>+<-]>. + +한 번 돌려보고 아래의 프로그램이 실제로 무슨 일을 하는지 맞춰보세요: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +이 프로그램은 두 개의 숫자를 입력받은 뒤, 그 둘을 곱합니다. + +위 코드는 일단 두 번의 입력을 받고, 첫번째 칸의 값만큼 바깥 루프를 돕니다. +그리고 루프 안에서 다시 두번째 칸의 값만큼 안쪽의 루프를 돕니다. +그리고 그 루프에서는 세번째 칸의 값을 증가시키는데, 문제가 하나 있습니다: +내부 루프가 한 번 끝나게 되면 두번째 칸의 값은 0이 됩니다. +그럼 다시 바깥 루프를 돌 때에 안쪽의 루프를 돌지 않게 되는데, 이를 해결하려면 +네번째 칸의 값도 같이 증가시킨 다음, 그 값을 두번째 칸으로 옮기면 됩니다. +그러면 세번째 칸에 곱셈의 결과가 남습니다. +``` + +여기까지 브레인퍽이었습니다. 참 쉽죠? +재미삼아 브레인퍽 프로그램이나 다른 언어로 브레인퍽 인터프리터를 작성해보세요. +인터프리터 구현은 간단한 편인데, +사서 고생하는 것을 즐기는 편이라면 한 번 작성해보세요… 브레인퍽으로. diff --git a/ko-kr/clojure-kr.html.markdown b/ko-kr/clojure-kr.html.markdown new file mode 100644 index 00000000..1d9e53cd --- /dev/null +++ b/ko-kr/clojure-kr.html.markdown @@ -0,0 +1,383 @@ +--- +language: clojure +filename: learnclojure-kr.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["netpyoung", "http://netpyoung.github.io/"] +lang: ko-kr +--- + +Clojure는 Java 가상머신을 위해 개발된 Lisp 계통의 언어입니다 +이는 Common Lisp보다 순수 [함수형 프로그래밍](https://en.wikipedia.org/wiki/Functional_programming)을 더욱 강조했으며, +상태를 있는 그대로 다루기 위해 다양한 [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) 을 지원하는 프로그램들을 갖췄습니다. + +이를 조합하여, 병행처리(concurrent processing)를 매우 단순하게 처리할 수 있으며, +대게 자동으로 처리될 수 있도록 만들 수 있습니다. + +(Clojure 1.2 이상의 버전이 필요로 합니다.) + + +```clojure +; 주석은 세미콜론(;)으로 시작합니다. + +; Clojure는 "폼(forms)"으로 구성되었으며, +; 폼은 괄호로 감싸져있으며, 공백으로 구분된 것들이 나열된 것입니다. +; +; clojure의 reader는 첫번째로 오는 것을 +; 함수 혹은 매크로를 호출하는 것, 그리고 나머지를 인자라고 가정합니다. + +; namespace를 지정하기 위해, 파일에서 우선적으로 호출해야될 것은 ns입니다. +(ns learnclojure) + +; 간단한 예제들: + +; str 은 인자로 받은 것들을 하나의 문자열로 만들어줍니다. +(str "Hello" " " "World") ; => "Hello World" + +; 직관적인 수학 함수들을 갖고 있습니다. +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; = 로 동일성을 판별할 수 있습니다. +(= 1 1) ; => true +(= 2 1) ; => false + +; 논리연산을 위한 not 역시 필요합니다. +(not true) ; => false + +; 중첩된 폼(forms)은 기대한대로 동작합니다. +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; 타입 +;;;;;;;;;;;;; + +; Clojure는 부울(boolean), 문자열, 숫자를 위해 Java의 object 타입을 이용합니다. +; `class` 를 이용하여 이를 확인할 수 있습니다. +(class 1) ; 정수는 기본적으로 java.lang.Long입니다. +(class 1.); 소수는 java.lang.Double입니다. +(class ""); 문자열은 쌍따옴표로 감싸져 있으며, java.lang.String입니다. +(class false) ; 부울값은 java.lang.Boolean입니다. +(class nil); nil은 "null"값입니다. + +; 데이터 리스트 자체를 만들고자 한다면, +; '를 이용하여 평가(evaluate)되지 않도록 막아야 합니다. +'(+ 1 2) ; => (+ 1 2) +; (quote (+ 1 2)) 를 줄여서 쓴것 + +; quote 가 된 리스트를 평가할 수 도 있습니다. +(eval '(+ 1 2)) ; => 3 + +; 컬렉션(Collections) & 시퀀스(Sequences) +;;;;;;;;;;;;;;;;;;; + +; 리스트(List)는 연결된(linked-list) 자료구조이며, 벡터(Vector)는 배열이 뒤로붙는(array-backed) 자료구조입니다. +; 리스트와 벡터 모두 java 클래스입니다! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; 간단하게 (1 2 3)로 리스트를 나타낼 수 있지만, +; reader가 함수라고 여기지 못하게 quote(')를 해줘야 합니다. +; 따라서, (list 1 2 3)는 '(1 2 3)와 같습니다. + +; "컬렉션"은 단순하게 데이터의 그룹입니다. +; 리스트와 벡터 모두 컬렉션입니다: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; "시퀀스" (seq) 는 데이터 리스트를 추상적으로 기술한 것입니다. +; 리스트는 시퀀스입니다. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; 시퀀스는 접근하고자 하는 항목만 제공해주면 됩니다. +; 따라서, 시퀀스는 lazy 할 수 있습니다 -- 무한하게 늘어나는 것을 정의할 수 있습니다: +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (an infinite series) +(take 4 (range)) ; (0 1 2 3) + +; cons 를 이용하여 리스트나 벡터의 시작부에 항목을 추가할 수 있습니다. +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; conj 는 컬렉션에 가장 효율적인 방식으로 항목을 추가합니다. +; 리스트는 시작부분에 삽입하고, 벡터는 끝부분에 삽입합니다. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; concat 을 이용하여 리스트와 벡터를 서로 합칠 수 있습니다. +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; filter, map 을 이용하여 컬렉션을 다룰 수 있습니다. +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; reduce 를 이용하여 줄여나갈 수 있습니다. +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; reduce 는 초기 값을 인자로 취할 수 도 있습니다. +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; 함수 +;;;;;;;;;;;;;;;;;;;;; + +; fn 을 이용하여 함수를 만들 수 있습니다 . +; 함수는 항상 마지막 문장을 반환합니다. +(fn [] "Hello World") ; => fn + +; (정의한 것을 호출하기 위해선, 괄호가 더 필요합니다.) +((fn [] "Hello World")) ; => "Hello World" + +; def 를 이용하여 var 를 만들 수 있습니다. +(def x 1) +x ; => 1 + +; var 에 함수를 할당시켜보겠습니다. +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; defn 을 이용하여 짧게 쓸 수 도 있습니다. +(defn hello-world [] "Hello World") + +; [] 는 함수의 인자 목록을 나타냅니다. +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; 약자(shorthand)를 써서 함수를 만들 수 도 있습니다: +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; 함수가 다양한 인자를 받도록 정의할 수 도 있습니다. +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; 함수는 여러 인자를 시퀀스로 취할 수 있습니다. +(defn count-args [& args] + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" + +; 개별적으로 받는 것과, 시퀀스로 취하는 것을 같이 쓸 수 도 있습니다. +(defn hello-count [name & args] + (str "Hello " name ", you passed " (count args) " extra args")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" + + +; 맵(Maps) +;;;;;;;;;; + +; 해쉬맵(hash map)과 배열맵(array map)은 공통된 인터페이스를 공유합니다. +; 해쉬맵은 찾기가 빠르지만, 키의 순서가 유지되지 않습니다. +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; 배열맵은 여러 연산을 거쳐 자연스레 해쉬맵이 됩니다. +; 만일 이게 커진다 하더라도, 걱정할 필요가 없습니다. + +; 맵은 해쉬가 가능한 타입이라면 어떠한 것이든 키로써 활용이 가능하지만, 보통 키워드를 이용하는 것이 가장 좋습니다. +; 키워드(Keyword)는 문자열과 비슷하지만, 보다 효율적인 면이 있습니다. +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; 여기서, 쉽표가 공백으로 취급되며, 아무 일도 하지 않는다는 것을 주목하시기 바랍니다. + +; 맵에서 값을 얻어오기 위해선, 함수로써 맵을 호출해야 합니다. +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; 키워드 역시 맵에서 함수를 얻어올 때 사용할 수 있습니다! +(:b keymap) ; => 2 + +; 하지만, 문자열로는 하면 안됩니다. +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; 없는 값을 얻어오고자 하면, nil이 반환됩니다. +(stringmap "d") ; => nil + +; assoc 를 이용하여 해쉬맵에 새로운 키를 추가할 수 있습니다. +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; 하지만, 변경할 수 없는(immutable) clojure 타입이라는 것을 기억해야 합니다! +keymap ; => {:a 1, :b 2, :c 3} + +; dissoc 를 이용하여 키를 제거할 수 있습니다. +(dissoc keymap :a :b) ; => {:c 3} + +; 쎗(Set:집합) +;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; conj 로 항목을 추가할 수 있습니다. +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; disj 로 제거할 수 도 있습니다. +(disj #{1 2 3} 1) ; => #{2 3} + +; 존재하는지 확인할 목적으로, 쎗을 함수로 사용할 수 도 있습니다. +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; clojure.sets 네임스페이스(namespace)에는 더 많은 함수들이 있습니다. + +; 유용한 폼(forms) +;;;;;;;;;;;;;;;;; + +; clojure에선, if 와 매크로(macro)를 가지고, +; 다른 여러 논리 연산들을 만들 수 있습니다. +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; let 을 이용하여 임시적으로 바인딩(binding)을 구축할 수 있습니다. +(let [a 1 b 2] + (> a b)) ; => false + +; do 로 문단을 묶을 수 도 있습니다. +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; 함수는 암시적으로 do 를 가지고 있습니다. +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; let 역시 그러합니다. +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; 모듈(Modules) +;;;;;;;;;;;;;;; + +; "use" 를 이용하여 module에 있는 모든 함수들을 얻어올 수 있습니다. +(use 'clojure.set) + +; 이제 쎗(set:집합)연산을 사용 할 수 있습니다. +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; 함수들 중에 일 부분만을 가져올 수 도 있습니다. +(use '[clojure.set :only [intersection]]) + +; require 를 이용하여 모듈을 import할 수 있습니다. +(require 'clojure.string) + +; / 를 이용하여 모듈에 있는 함수를 호출 할 수 있습니다. +; 여기, clojure.string 라는 모듈에, blank? 라는 함수가 있습니다. +(clojure.string/blank? "") ; => true + +; import시, 모듈에 짧은 이름을 붙여줄 수 있습니다. +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (#"" denotes a regular expression literal) + +; :require 를 이용하여, 네임스페이스에서 require 를 사용할 수 있습니다. +; 아레와 같은 방법을 이용하면, 모듈을 quote하지 않아도 됩니다. +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java는 유용한 많은 표준 라이브러리를 가지고 있으며, +; 이를 어떻게 활용할 수 있는지 알아보도록 하겠습니다. + +; import 로 java 모듈을 불러올 수 있습니다. +(import java.util.Date) + +; ns 와 함께 import 를 할 수 도 있습니다. +(ns test + (:import java.util.Date + java.util.Calendar)) + +; 새로운 인스턴스를 만들기 위해선, 클래스 이름 끝에 "."을 찍습니다. +(Date.) ; <a date object> + +; . 을 이용하여 메소드를 호출할 수 있습니다. +; 아니면, 줄여서 ".메소드"로도 호출 할 수 있습니다. +(. (Date.) getTime) ; <a timestamp> +(.getTime (Date.)) ; exactly the same thing. + +; / 를 이용하여 정적메소드를 호출 할 수 있습니다. +(System/currentTimeMillis) ; <a timestamp> (system is always present) + +; doto 를 이용하여 상태가 변하는(mutable) 클래스들을 좀 더 편하게(tolerable) 다룰 수 있습니다. +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; Software Transactional Memory 는 clojure가 영구적인(persistent) 상태를 다루는 방식입니다. +; clojure가 이용하는 몇몇 자료형(construct)이 있습니다. + +; 가장 단순한 것은 atom 입니다. 초기 값을 넣어보도록 하겠습니다. +(def my-atom (atom {})) + +; swap! 으로 atom을 갱신(update)할 수 있습니다! +; swap! 은 함수를 인자로 받아, 그 함수에 대해 현재 atom에 들어있는 값을 첫번째 인자로, +; 나머지를 두번째 인자로 하여 호출합니다. +(swap! my-atom assoc :a 1) ; Sets my-atom to the result of (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Sets my-atom to the result of (assoc {:a 1} :b 2) + +; '@' 를 이용하여 atom을 역참조(dereference)하여 값을 얻을 수 있습니다. +my-atom ;=> Atom<#...> (atom 객체가 반환됩니다.) +@my-atom ; => {:a 1 :b 2} + +; 여기 atom을 이용한 단순한 카운터가 있습니다. +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; STM을 구성하는 다른 것들에는 ref 와 agent 가 있습니다. +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### 읽어볼거리 + +부족한 것이 많았지만, 다행히도 채울 수 있는 것들이 많이 있습니다. + +Clojure.org에 많은 문서들이 보관되어 있습니다: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org는 core 함수들에 대해 다양한 예제와 문서를 보유하고 있습니다: +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure는 clojure/FP 스킬을 올릴 수 있는 좋은 길입니다: +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org는 많고 많은 문서들을 보유하고 있습니다: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/ko-kr/coffeescript-kr.html.markdown b/ko-kr/coffeescript-kr.html.markdown new file mode 100644 index 00000000..f8ac8069 --- /dev/null +++ b/ko-kr/coffeescript-kr.html.markdown @@ -0,0 +1,58 @@ +--- +language: coffeescript +category: language +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +filename: coffeescript-kr.coffee +translators: + - ["wikibook", "http://wikibook.co.kr"] +lang: ko-kr +--- + +``` coffeescript +# 커피스크립트(CoffeeScript)는 최신 유행을 따르는 언어입니다. +# 커피스크립트는 여러 현대 언어의 트렌드를 따르는데, +# 그래서 주석을 작성할 때는 루비나 파이썬과 같이 해시를 씁니다. + +### +블록 주석은 이처럼 작성하며, 자바스크립트 코드로 만들어지도록 +'/ *'와 '* /'로 직접적으로 변환됩니다. + +계속하기에 앞서 자바스크립트 시맨틱을 대부분 이해하고 있어야 합니다. +### + +# 할당: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# 조건문: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# 함수: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +# 범위: +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# 객체: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# 가변 인자(splat): +race = (winner, runners...) -> + print winner, runners + +# 존재 여부 확인: +alert "I knew it!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# 배열 조건 제시법(comprehensions): +cubes = (math.cube num for num in list) #=> ... +``` diff --git a/ko-kr/go-kr.html.markdown b/ko-kr/go-kr.html.markdown new file mode 100644 index 00000000..3012c04f --- /dev/null +++ b/ko-kr/go-kr.html.markdown @@ -0,0 +1,346 @@ +--- +name: Go +category: language +language: Go +filename: learngo-kr.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] +translators: + - ["Jongmin Kim", "http://github.com/atomaths"] + - ["Peter Lee", "http://github.com/ins429"] +lang: ko-kr +--- + +Go는 어떤 일을 잘 끝낼 수 있도록 하기위해 만들어졌다. Go가 잘 알려진 최신의 +트렌드는 아니지만, 실세계의 문제들을 해결하기 위해서는 가장 +새롭고 빠른 방법이다. + +Go는 정적 타이핑(static typing)의 명령형 언어들(imperative languages)이 +갖고 있는 특징과 유사한 개념들을 가지고 있다. Go는 컴파일과 실행속도가 +빠르며, 오늘날의 멀티코어 CPU를 위해 이해하기 쉬운 동시성(concurrency) +기능이 추가되었다. 그리고 큰 스케일의 프로그래밍에도 도움이 되는 +기능들을 가지고 있다. + +또한 Go에는 훌륭한 표준 라이브러리와 열정적인 커뮤니티가 있다. + +```go +// 한 줄 주석 +/* 여러 줄 + 주석 */ + +// 모든 Go 소스 파일은 package로 시작한다. +// 패키지 이름 중 main은 라이브러리가 아닌 실행파일을 선언하는 특별한 이름이다. +package main + +// import는 이 Go 소스 파일 내에서 참조하는 라이브러리 패키지들을 선언한다. +import ( + "fmt" // Go 표준 라이브러리에 있는 패키지 + "net/http" // 표준 라이브러리에는 웹 서버 패키지도 있다! (클라이언트도 있음) + "strconv" // 문자열 변환 패키지 +) + +// 함수 선언. main은 실행 프로그램에서 시작점이 되는 특별한 함수다. +// 중괄호를 사용한다. +func main() { + // Println은 표준 출력으로 개행을 출력한다. + // fmt 패키지를 통해 이용할 수 있다. + fmt.Println("Hello world!") + + // 다른 함수를 호출한다. + beyondHello() +} + +// 함수에 파라미터가 없더라도 빈 괄호는 있어야 한다. +func beyondHello() { + var x int // 변수 선언. 변수는 사용하기 전에 선언해야 한다. + x = 3 // 변수에 값 할당. + // 짧은 선언(short declaration)으로 := 를 사용하는데, + // 이렇게 값을 할당하면 값의 타입에 따라 변수의 타입이 결정된다. + y := 4 + sum, prod := learnMultiple(x, y) // 함수는 두 개 이상의 리턴 값을 줄 수 있다. + fmt.Println("sum:", sum, "prod:", prod) // 간단한 출력 + learnTypes() // 잠시 후에 좀더 자세히! +} + +// 함수는 파라미터들을 가질 수 있고, 복수개의 값을 리턴할 수 있다. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // 두 개의 값을 리턴. +} + +// 내장 타입과 리터럴 +func learnTypes() { + // 짧은 선언은 유용하다. + s := "Learn Go!" // string 타입 + + s2 := `역따옴표 안의 string 리터럴은 +개행을 포함할 수 있다.` // 같은 string 타입 + + // non-ASCII 리터럴. Go 소스는 UTF-8로 작성해야 한다. + g := 'Σ' // 유니코드 코드 포인트를 담고 있고, int32 타입의 가칭(alias)인 rune 타입 + + f := 3.14195 // float64, an IEEE-754 64-bit 부동소수 타입 + c := 3 + 4i // complex128, 내부적으로는 두 개의 float64 타입으로 표현됨 + + // 초기값과 함께 사용하는 var 키워드. + var u uint = 7 // unsigned, 하지만 int에 따른 구현의존적인 크기 + var pi float32 = 22. / 7 + + // 짧은 선언으로 변환(conversion)하는 문법. + // Go에서는 type casting 이라고 하지않고 type conversion 이라고 함. + n := byte('\n') // byte는 uint8의 가칭(alias) + + // 배열은 컴파일 시에 크기가 정해진다. + var a4 [4]int // 모두 0으로 초기화되는 int 타입 4개짜리 배열 + a3 := [...]int{3, 1, 5} // 3, 1, 5로 초기화되는 int 타입 3개짜리 배열 + + // 슬라이스(slice)라고 하는 타입은 배열에 대한 가변 크기를 가진다. + // 배열, 슬라이스 각자 장점이 있지만, 슬라이스가 더 많이 사용된다. + s3 := []int{4, 5, 9} // 위의 a3와 비교해보면 생략부호(...)가 없다. + s4 := make([]int, 4) // 모두 0으로 초기화되는 int 4개에 대한 슬라이스를 할당. + var d2 [][]float64 // 여기에서는 선언만 있고 할당은 없다. + bs := []byte("a slice") // string 타입을 byte 슬라이스 타입으로 형변환(type conversion) + + p, q := learnMemory() // int에 대한 포인터 타입인 p와 q를 선언 + fmt.Println(*p, *q) // C에서처럼 *는 포인터를 따라가 값을 참조한다. 여기서는 두 개의 int를 출력. + + // 맵(map)은 다른 언어의 해시(hash)나 딕셔너리(dictionary)처럼 가변의 연관배열 타입. + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + // 선언만 하고 사용하지 않는 변수가 있다면 Go에서는 컴파일 시 에러가 난다. + // 언더바를 이용해서 변수를 사용한 것처럼 하고 그 값은 무시해버릴 수 있다. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // 물론 출력을 하면 변수로 취급한다. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // 잠시 후에 다시 나옴 +} + +// Go는 가비지 컬렉션 기능을 JVM 같은 곳이 아닌 실행파일 런타임에 포함하고 있다. +// 그리고 포인터는 있지만, 포인터 연산(*p++ 같은)은 없다. +// 그래서 nil 포인터 접근같은 것 때문에 실수를 할 수는 있지만 +// 포인터 연산으로 인한 실수는 없게 된다. +func learnMemory() (p, q *int) { + // 지명된 리턴 값(named return value)인 p와 q는 int에 대한 포인터 타입이다. + p = new(int) // 내장함수인 new는 메모리를 할당해준다. + // 메모리 할당된 int는 0으로 초기화 되고, p는 이제 nil이 아니다. + s := make([]int, 20) // 메모리의 단일 블록으로 20개의 int 공간을 할당한다. + s[3] = 7 // 그중 하나에 값을 준다. + r := -2 // 또다른 로컬 변수를 선언한다. + return &s[3], &r // &는 어떤 대상체의 메모리 주소를 가져오게 된다. +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // if문에 중괄호는 필요하지만, 조건이 들어갈 곳에 소괄호는 쓰지 않는다. + if true { + fmt.Println("told ya") + } + // 모든 Go 소스의 코드 포맷팅은 "go fmt" 커맨드라인 명령으로 소스코드의 포맷을 맞춘다. + if false { + // pout + } else { + // gloat + } + // if-else 체인 형태보다 switch 사용이 권장된다. + x := 1 + switch x { + case 0: + case 1: + // case 안에서는 break가 없어도 자동으로 다음 case로 내려가지 않는다. + // 자동으로 내려가게 하려면 fallthrough 키워드를 사용한다. + case 2: + // x는 1이므로 여기는 실행되지 않음. + } + // if 에서처럼 for 에서도 양쪽에 소괄호를 쓰지 않는다. + for x := 0; x < 3; x++ { // ++ 은 실행을 제어하는 하나의 구문(statement)이다. + fmt.Println("iteration", x) + } + // 여기서 x는 1이다. 위 for에서 x는 for 안의 블록 범위에 있기 때문. + + // For is the only loop statement in Go, but it has alternate forms. + // for 는 Go에서 유일한 루프 구문이지만 다양한 형태로 조건을 주거나 while + // 처럼 쓸 수도 있다. + for { // 무한루프 + break // 여기서 곧바로 break를 한 건 단지 + continue // break, continue를 루프 안에서 쓸 수 있다는 것을 보여주기 위함. + } + // for 에서처럼 if 에서 := 를 사용하는것은 y에 먼저 값을 대입하고, + // 그리고 y > x를 검사한다는 의미. + if y := expensiveComputation(); y > x { + x = y + } + // 함수 리터럴은 클로저다. + xBig := func() bool { + return x > 100 // 위 switch 문 바로 위에 있는 x를 참조한다. + } + fmt.Println("xBig:", xBig()) // true (x에 1e6를 대입했었다.) + x /= 1e5 // x는 10이 된다. + fmt.Println("xBig:", xBig()) // 이제 xBig()의 결과는 false가 된다. + + // `goto`가 필요하다면, 좋아하게 될지도... + goto love +love: + + learnDefer() // defer에 대해 + learnInterfaces() // 곧이어서 좋은 기능에 대한 설명이 나올 거다. +} + +func learnDefer() (ok bool) { + // deferred statements are executed just before the function returns. + // 연기된(deferred) 구문은 함수가 리턴하기 직전에 실행된다. + defer fmt.Println("deferred statements execute in reverse (LIFO) order.") // 연기된 구문은 LIFO순으로 실행된다. + defer fmt.Println("\nThis line is being printed first because") // 이 줄이 먼저 실행된다. + // defer는 주로 파일을 닫는데 사용된다. + // 파일을 닫는함수를 파일을 여는함수에 가까이 둘수 있다. + return true +} + +// String 이라는 메서드 하나를 가진 Stringer 라는 인터페이스 타입을 정의하자. +type Stringer interface { + String() string +} + +// x와 y라는 이름의 int 타입 필드를 가진 pair라는 struct를 정의하자. +type pair struct { + x, y int +} + +// pair 타입에 메서드 String을 정의하자. +// 이제 pair는 Stringer 인터페이스를 구현(implement)한 것이 되었다. +func (p pair) String() string { // 여기서 p는 리시버(receiver)라고 부른다. + // Sprintf는 fmt 패키지 안에 있는 외부로 공개된(exported) 함수다. + // 점(.)으로 p의 필드들을 참조할 수 있다. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // 중괄호 문법은 "구조체 리터럴(struct literal)"인데, 초기화된 구조체로 + // 취급하게 해준다. := 문법으로 p를 이 구조체로 선언하고 초기화한다. + p := pair{3, 4} + fmt.Println(p.String()) // 타입 pair인 p의 String 메서드를 호출. + var i Stringer // Stringer 인터페이스 타입 i를 선언. + i = p // pair는 Stringer를 구현했기 때문에 이 대입은 유효하다. + // 타입 Stringer인 i의 String 메서드 호출. 결과는 위와 같다. + fmt.Println(i.String()) + + // fmt 패키지의 함수들을 통해 어떤 객체를 출력해보려고 할 때, + // fmt 패키지 내에서는 그 객체가 가진 String 메서드를 호출하도록 되어 있다. + fmt.Println(p) // 결과는 위와 같다. Println은 String 메서드를 호출한다. + fmt.Println(i) // 결과는 위와 같다. + + learnVariadicParams("great", "learning", "here!") +} + +// 함수는 가변 인수(variadic) 파라미터를 가질수 있다. +func learnVariadicParams(myStrings ...interface{}) { + // 가변 인수를 차례로 반복한다. + // 여기서 언더바(언더스코어, `_`)는 배열의 인덱스 인수를 무시한다. + // The underbar here is ignoring the index argument of the array. + for _, param := range myStrings { + fmt.Println("param:", param) + } + + // 가변 인수 값을 가변인수 파라미터로 보내기. + fmt.Println("params:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" (comma okay)표현은 무언가가 맞는 것인지 아닌지 확인하는데 사용된다. + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // 이 map 안에 키가 1인 것은 없으므로 ok는 false가 된다. + fmt.Println("no one there") + } else { + fmt.Print(x) // 만일 1이 map에 있었다면 x는 키 1의 값이 들어가게 된다. + } + + // Go에서는 함수가 복수 개의 리턴 값을 줄 수 있다는 점을 활용해 함수의 두 번째 리턴 + // 값으로 error를 리턴해주고 그 error가 nil 인지 아닌지 확인하는 관례가 있다. + // 이때 이 error 값은 단지 위에서처럼 함수의 결과가 성공했는지 실패했는지를 확인하는 + // 것뿐만 아니라 실패 시 어떤 문제가 있었는지 확인할 수 있는 수단도 된다. + if _, err := strconv.Atoi("non-int"); err != nil { // _ 는 값을 안 쓰고 버린다는 의미. + // "strconv.ParseInt: parsing "non-int": invalid syntax" 이런 에러가 출력된다. + fmt.Println(err) + } + // 인터페이스에 대해 잠시 후에 다시 잠깐 볼 것이다. + learnConcurrency() +} + +// c는 goroutine 간의 통신을 위한 채널(channel)이다. +func inc(i int, c chan int) { + c <- i + 1 // 채널이 <- 이 연산자 왼쪽에 온다면 그 채널로 데이터를 보낸다는 의미다. +} + +// 우리는 어떤 숫자들을 동시에 증가시키기 위해 inc 함수를 사용할 것이다. +func learnConcurrency() { + // make는 slice, map, channel 타입들에 대해 메모리를 할당하고 초기화를 한다. + // Go에는 메모리 할당 방법으로 new와 make가 있다. + c := make(chan int) + // 3개의 동시에 실행되는 goroutine를 시작한다. 만약 실행하고 있는 머신이 + // 멀티코어 CPU를 가지고 있고 올바르게 설정되어(GOMAXPROCS) 있다면 + // 숫자가 정말로 병렬적으로 증가하게 될 것이다. + go inc(0, c) // go는 새로운 goroutine을 시작하는 구문이다. + go inc(10, c) + go inc(-805, c) + // 채널로부터 3개의 결과를 읽어 출력한다. + // 결과가 어떤 순서로 오는지는 알 수 없다. + fmt.Println(<-c, <-c, <-c) // 채널이 <- 연산자 오른쪽에 있는 건, 채널로부터 데이터를 받는 연산이다. + + cs := make(chan string) // string을 다루는 또 다른 채널 + cc := make(chan chan string) // string 채널의 채널 + go func() { c <- 84 }() // c 채널로 값을 보내는 goroutine 시작. + go func() { cs <- "wordy" }() // cs 채널로 값을 보내느 goroutine 시작. + // select 구문은 switch 문과 비슷하지만, case에서 채널 연산에 관한 일을 한다. + // select의 case들은 채널통신을 할 준비가 된 case 하나가 무작위로 선택되어 + // 그 부분이 실행된다. + select { + case i := <-c: // 채널로부터 받아진 값은 변수에 대입할 수 있다. + fmt.Printf("it's a %T", i) + case <-cs: // 또는 받은 값을 그냥 버릴 수도 있다. + fmt.Println("it's a string") + case <-cc: // 통신할 준비가 되어 있지 않은 비어있는 채널. + fmt.Println("didn't happen.") + } + // 여기서는 c나 cs 채널로부터 값 하나를 받을 수 있다. 위에서 실행한 두 개의 + // goroutine 중 하나가 완료되면 다른 하나는 블락된 상태로 있게 된다. + + learnWebProgramming() // Go에서는 웹 서버쪽 개발도 쉽게 할 수 있다. +} + +// http 패키지의 함수 하나로 웹 서버를 실행시킨다. +func learnWebProgramming() { + // ListenAndServe의 첫 번째 파라미터는 listen 하기 위한 TCP 주소고, + // 두 번째 파라미터는 http.Handler 인터페이스다. + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // don't ignore errors +} + +// http.Handler의 하나 뿐인 메서드, ServeHTTP를 pair에서 구현한다. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // http.ResponseWriter의 메서드로 클라이언트에게 데이터를 보낸다. + w.Write([]byte("You learned Go in Y minutes!")) +} +``` + +## 더 읽어볼 것들 + +Go에 대한 모든 것들은 [Go 공식 웹 사이트](http://golang.org/)를 참고하자. +여기에는 따라해볼 튜토리얼, 웹 기반의 인터랙티브 실행환경과 많은 읽을거리들이 있다. + +Go 언어 자체에 대한 스펙도 읽어보기를 적극 추천한다. 읽기 쉽게 되어있고 +그리 길지는 않다. + +Go 소스코드에 대해 좀더 알아보고 싶다면 [Go 표준 라이브러리](http://golang.org/src/pkg/)를 +분석해보기 바란다. 이해하기 쉽게 문서화되어 있고, Go 스타일 그리고 Go에서의 +관례 배우기에 가장 좋은 방법일 것이다. 또는 [문서](http://golang.org/pkg/) 안에서 +함수 이름 하나를 클릭해보면 소스코드를 브라우저에서 살펴볼 수도 있다. + +Go를 배울수 있는 또하나의 좋은 방법은 [Go by example](https://gobyexample.com/). diff --git a/ko-kr/java-kr.html.markdown b/ko-kr/java-kr.html.markdown new file mode 100644 index 00000000..dc7a356f --- /dev/null +++ b/ko-kr/java-kr.html.markdown @@ -0,0 +1,408 @@ +--- +language: java +filename: java-kr.java +category: language +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["wikibook", "http://wikibook.co.kr"] +lang: ko-kr +--- + +자바는 일반 목적으로 사용할 수 있고 동시성을 지원하며, 클래스 기반의 객체지향 컴퓨터 프로그래밍 언어입니다. +[더 자세한 사항](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// 한 줄짜리 주석은 //로 시작합니다. +/* +여러 줄 주석은 다음과 같은 형태입니다. +*/ +/** +자바독(JavaDoc) 주석은 이렇게 생겼습니다. 자바독 주석은 클래스나 클래스의 +다양한 속성을 기술하는 데 사용됩니다. +*/ + +// java.util 패키지 안에 있는 ArrayList 클래스를 임포트합니다. +import java.util.ArrayList; +// java.security 패키지 안에 있는 모든 클래스를 임포트합니다. +import java.security.*; + +// 각 .java 파일에는 공용(public) 클래스가 들어 있으며, 클래스의 이름은 +// 파일명과 동일합니다. +public class LearnJava { + + // 프로그램에는 반드시 진입점 역할을 하는 main 메서드가 하나 있어야 합니다. + public static void main (String[] args) { + + // System.out.println을 이용해 한 줄을 출력합니다. + System.out.println("Hello World!"); + System.out.println( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // 줄바꿈 없이 뭔가를 출력하려면 System.out.print를 사용합니다. + System.out.print("Hello "); + System.out.print("World"); + + + /////////////////////////////////////// + // 타입 & 변수 + /////////////////////////////////////// + + // <타입> <이름>과 같은 형태로 변수를 선언합니다. + // Byte - 부호가 있는 8비트 2의 보수 정수 + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - 부호가 있는 16비트 2의 보수 정수 + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - 부호가 있는 32비트 2의 보수 정수 + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - 부호가 있는 64비트 2의 보수 정수 + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L은 이 변수의 값이 Long 타입임을 나타내는 데 사용됩니다. + // L이 없는 것들은 기본적으로 정수로 간주됩니다. + + // 참고: 자바에는 부호 없는(unsigned) 타입이 없습니다. + + // Float - 단정도 32비트 IEEE 754 부동 소수점 수 + float fooFloat = 234.5f; + // f는 이 변수의 값이 float 타입임을 나타내는 데 사용됩니다. + // f를 지정하지 않으면 double로 간주됩니다. + + // Double - 배정도 64비트 IEEE 754 부동 소수점 수 + double fooDouble = 123.4; + + // Boolean - 참(true) & 거짓(false) + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - 단일 16비트 유니코드 문자 + char fooChar = 'A'; + + // 변수를 변경할 수 없게 만들려면 final을 지정합니다. + final int HOURS_I_WORK_PER_WEEK = 9001; + + // 문자열 + String fooString = "My String Is Here!"; + + // \n은 새로운 줄을 시작하는 이스케이프 문자입니다. + String barString = "Printing on a new line?\nNo Problem!"; + // \t는 탭 문자를 추가하는 이스케이프 문자입니다. + String bazString = "Do you want to add a tab?\tNo Problem!"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // 배열 + // 배열의 크기는 반드시 선언할 때 결정해야 합니다. + // 배열을 선언하는 형식은 다음과 같습니다. + //<자료형> [] <변수명> = new <자료형>[<배열 크기>]; + int [] intArray = new int[10]; + String [] stringArray = new String[1]; + boolean [] booleanArray = new boolean[100]; + + // 배열을 선언하고 초기화하는 또 다른 방법 + int [] y = {9000, 1000, 1337}; + + // 배열 인덱스 - 요소에 접근 + System.out.println("intArray @ 0: " + intArray[0]); + + // 배열의 인덱스는 0에서부터 시작하며 변경 가능합니다. + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // 기타 참고할 만한 자료구조 + // ArrayLists - 좀 더 많은 기능을 제공하고 크기를 변경 가능하다는 점을 + // 제외하면 배열과 비슷합니다. + // LinkedLists + // Maps + // HashMaps + + /////////////////////////////////////// + // 연산자 + /////////////////////////////////////// + System.out.println("\n->Operators"); + + int i1 = 1, i2 = 2; // 다중 선언의 축약형 + + // 산술 연산은 이해하기 어렵지 않습니다. + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5를 잘라 버립니다) + + // 나눗셈 + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // 비교 연산자 + System.out.println("3 == 2? " + (3 == 2)); // => false + System.out.println("3 != 2? " + (3 != 2)); // => true + System.out.println("3 > 2? " + (3 > 2)); // => true + System.out.println("3 < 2? " + (3 < 2)); // => false + System.out.println("2 <= 2? " + (2 <= 2)); // => true + System.out.println("2 >= 2? " + (2 >= 2)); // => true + + // 비트 연산자! + /* + ~ 단항 보수 연산 + << 산술적 왼쪽 시프트 + >> 산술적 오른쪽 시프트 + >>> 논리적 오른쪽 시프트 + & 비트 단위 논리곱(AND) + ^ 비트 단위 배타적 논리합(OR) + | 비트 단위 논리합(OR) + */ + + // 증감 연산자 + int i = 0; + System.out.println("\n->Inc/Dec-rementation"); + System.out.println(i++); //i = 1. 후치 증가 연산 + System.out.println(++i); //i = 2. 전치 증가 연산 + System.out.println(i--); //i = 1. 후치 감소 연산 + System.out.println(--i); //i = 0. 전치 감소 연산 + + /////////////////////////////////////// + // 제어 구조 + /////////////////////////////////////// + System.out.println("\n->Control Structures"); + + // if 문은 C 언어와 비슷합니다. + int j = 10; + if (j == 10){ + System.out.println("I get printed"); + } else if (j > 10) { + System.out.println("I don't"); + } else { + System.out.println("I also don't"); + } + + // while 루프 + int fooWhile = 0; + while(fooWhile < 100) + { + // System.out.println(fooWhile); + // 카운터를 증가 + // 99번 반복, fooWhile 0->99 + fooWhile++; + } + System.out.println("fooWhile Value: " + fooWhile); + + // do-while 루프 + int fooDoWhile = 0; + do + { + // System.out.println(fooDoWhile); + // 카운터를 증가 + // 99번 반복, fooDoWhile 0->99 + fooDoWhile++; + }while(fooDoWhile < 100); + System.out.println("fooDoWhile Value: " + fooDoWhile); + + // for 루프 + int fooFor; + // for 루프 구조 => for(<초기식>; <조건식>; <증감식>) + for(fooFor=0; fooFor<10; fooFor++){ + // System.out.println(fooFor); + // 10번 반복, fooFor 0->9 + } + System.out.println("fooFor Value: " + fooFor); + + // switch-case 문 + // switch는 byte, short, char, int 자료형을 대상으로 동작합니다. + // 아울러 열거형을 비롯해 String 클래스 및 원시 타입을 감싼 Character, + // Byte, Short, Integer와 같은 몇 가지 특별한 클래스에 대해서도 동작합니다. + int month = 3; + String monthString; + switch (month){ + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + default: + monthString = "Some other month"; + break; + } + System.out.println("Switch Case Result: " + monthString); + + + /////////////////////////////////////// + // 자료형 변환과 형변환 + /////////////////////////////////////// + + // 데이터 변환 + + // 문자열에서 정수로 변환 + Integer.parseInt("123");// 정수 버전의 "123"을 반환 + + // 정수를 문자열로 변환 + Integer.toString(123);// 문자열 버전의 123을 반환 + + // 다른 변환에 대해서는 아래 클래스를 확인해 보세요. + // Double + // Long + // String + + // 형변환 + // 자바 객체 또한 형변환할 수 있으며, 이와 관련해서 알아야 할 세부사항이 + // 많을뿐더러 다소 중급 수준에 해당하는 개념들도 다뤄야 합니다. + // 이와 관련된 사항은 아래 링크를 참고하세요. + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // 클래스와 함수 + /////////////////////////////////////// + + System.out.println("\n->Classes & Functions"); + + // (Bicycle 클래스의 정의) + + // 클래스를 인스턴스화하려면 new를 사용합니다. + Bicycle trek = new Bicycle(); + + // 객체의 메서드를 호출합니다. + trek.speedUp(3); // 항상 설정자 메서드와 접근자 메서드를 사용해야 합니다. + trek.setCadence(100); + + // 현재 객체의 값을 표시할 때는 관례적으로 toString을 사용합니다. + System.out.println("trek info: " + trek.toString()); + + } // main 메서드 끝 +} // LearnJava 클래스 끝 + + +// .java 파일 안에 다른 비공개 클래스를 포함할 수 있습니다. + + +// 클래스 선언 문법: +// <public/private/protected> class <클래스명>{ +// // 데이터 필드, 생성자, 함수가 모두 이곳에 들어갑니다. +// // 자바에서는 함수를 메서드라고 부릅니다. +// } + +class Bicycle { + + // Bicycle의 필드와 변수 + public int cadence; // Public: 어느 곳에서도 접근할 수 있습니다. + private int speed; // Private: 클래스 안에서만 접근할 수 있습니다. + protected int gear; // Protected: 현재 클래스와 하위 클래스에서 접근할 수 있습니다. + String name; // default: 현재 패키지 안에서만 접근할 수 있습니다. + + // 생성자는 클래스를 생성하는 방법 중 하나입니다. + // 다음은 기본 생성자입니다. + public Bicycle() { + gear = 1; + cadence = 50; + speed = 5; + name = "Bontrager"; + } + + // 다음은 구체화된 생성자입니다(인자를 담고 있습니다) + public Bicycle(int startCadence, int startSpeed, int startGear, String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // 함수 문법: + // <public/private/protected> <반환형> <함수명>(<인자>) + + // 자바 클래스는 필드에 대해 접근자 메서드와 설정자 메서드를 구현할 때가 많습니다. + + // 메서드 선언 문법: + // <유효범위> <반환형> <메서드명>(<인자>) + public int getCadence() { + return cadence; + } + + // void 메서드는 반환형이 필요하지 않습니다. + public void setCadence(int newValue) { + cadence = newValue; + } + + public void setGear(int newValue) { + gear = newValue; + } + + public void speedUp(int increment) { + speed += increment; + } + + public void slowDown(int decrement) { + speed -= decrement; + } + + public void setName(String newName) { + name = newName; + } + + public String getName() { + return name; + } + + // 현재 객체의 속성값을 표시하는 메서드 + @Override + public String toString() { + return "gear: " + gear + + " cadence: " + cadence + + " speed: " + speed + + " name: " + name; + } +} // Bicycle 클래스의 끝 + +// PennyFarthing은 Bicycle의 하위 클래스입니다. +class PennyFarthing extends Bicycle { + // (페니 파딩은 앞바퀴가 굉장히 큰 자전거입니다. 기어가 없죠.) + + public PennyFarthing(int startCadence, int startSpeed){ + // super를 이용해 부모 생성자를 호출합니다. + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // @annotation을 이용해 재정의하는 메서드를 표시해야 합니다. + // 애노테이션과 애노테이션의 용도에 관한 자세한 내용은 아래 링크를 참고하세요. + // 애노테이션: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } + +} + +``` + +## 기타 참고자료 + +다음 링크를 통해 다양한 주제를 이해하고 구글을 통해 구체적인 예제들을 찾아보세요. + +공부할 만한 기타 주제: + +* [썬/오라클의 자바 자습서](http://docs.oracle.com/javase/tutorial/index.html) + +* [자바 접근 제한자](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [객체 지향 프로그래밍 개념](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [상속(Inheritance)](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [다형성(Polymorphism)](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [추상화(Abstraction)](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [예외(Exceptions)](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [인터페이스(Interfaces)](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [제네릭(Generics)](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [자바 코딩 관례(Java Code Conventions)](http://www.oracle.com/technetwork/java/codeconv-138413.html) diff --git a/ko-kr/javascript-kr.html.markdown b/ko-kr/javascript-kr.html.markdown new file mode 100644 index 00000000..9561e80c --- /dev/null +++ b/ko-kr/javascript-kr.html.markdown @@ -0,0 +1,433 @@ +--- +language: javascript +category: language +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] +translators: + - ["wikibook", "http://wikibook.co.kr"] +filename: javascript-kr.js +lang: ko-kr +--- + +자바스크립트는 넷스케이프의 브렌던 아이크(Brendan Eich)가 1995년에 만들었습니다. +원래 자바스크립트는 웹사이트를 위한 단순한 스크립트 언어를 목표로 만들어졌는데, +좀 더 복잡한 웹 애플리케이션을 만들기 위해 자바를 보완하는 역할이었지만 +웹 페이지와의 긴밀한 상호작용과 브라우저에 대한 지원 기능 덕분에 웹 프론트엔드에서 +자바보다 훨씬 더 보편적으로 쓰이게 됐습니다. + +그렇지만 자바스크립트는 웹 브라우저에만 국한되지 않습니다. 구글 크롬의 V8 자바스크립트 +엔진을 위한 독립형 런타임을 제공하는 Node.js는 점점 인기를 얻고 있습니다. + +피드백 주시면 대단히 감사하겠습니다! [@adambrenecki](https://twitter.com/adambrenecki)나 +[adam@brenecki.id.au](mailto:adam@brenecki.id.au)를 통해 저와 만나실 수 있습니다. + +```js +// 주석은 C와 비슷합니다. 한 줄짜리 주석은 두 개의 슬래시로 시작하고, +/* 여러 줄 주석은 슬래시 별표로 시작해서 + 별표 슬래시로 끝납니다. */ + +// 구문은 세미콜론(;)으로 끝낼 수 있습니다. +doStuff(); + +// 하지만 꼭 그럴 필요는 없는데, 특정 경우를 제외하고 +// 새 줄이 시작할 때마다 세미콜론이 자동으로 삽입되기 때문입니다. +doStuff() + +// 여기서는 세미콜론을 생략하겠습니다. 세미콜론을 생략할지 여부는 +// 개인적인 취향이나 프로젝트의 스타일 가이드를 따릅니다. + +/////////////////////////////////// +// 1. 숫자, 문자열, 연산자 + +// 자바스크립트에는 단 하나의 숫자 타입(64비트 IEEE 754 배정도 숫자)만이 +// 있습니다. +3 // = 3 +1.5 // = 1.5 + +// 모든 기초 산술 연산은 기대한 대로 동작합니다. +1 + 1 // = 2 +8 - 1 // = 7 +10 * 2 // = 20 +35 / 5 // = 7 + +// 나누어 떨어지지 않는 나눗셈도 포함됩니다. +5 / 2 // = 2.5 + +// 비트 연산도 지원됩니다. float을 대상으로 비트 연산을 수행하면 +// 32비트까지 부호가 있는 int로 변환됩니다. +1 << 2 // = 4 + +// 괄호를 이용하면 우선순위를 지정할 수 있습니다. +(1 + 3) * 2 // = 8 + +// 실제 숫자가 아닌 특별한 세 가지 값이 있습니다. +Infinity // 1/0 1/0과 같은 연산의 결과 +-Infinity // -1/0과 같은 연산의 결과 +NaN // 0/0과 같은 연산의 결과 + +// 불린 타입도 있습니다. +true +false + +// 문자열은 '나 "로 생성합니다. +'abc' +"Hello, world" + +// 부정 연산에는 ! 기호를 이용합니다. +!true // = false +!false // = true + +// 동일성 연산은 == +1 == 1 // = true +2 == 1 // = false + +// 불일치 연산은 != +1 != 1 // = false +2 != 1 // = true + +// 그 밖의 비교 연산 +1 < 10 // = true +1 > 10 // = false +2 <= 2 // = true +2 >= 2 // = true + +// 문자열은 +로 연결할 수 있습니다. +"Hello " + "world!" // = "Hello world!" + +// 그리고 <와 >로 비교할 수 있습니다. +"a" < "b" // = true + +// 비교 시 타입 강제변환이 수행됩니다. +"5" == 5 // = true + +// ===를 쓰지 않는다면 말이죠. +"5" === 5 // = false + +// charAt을 이용하면 문자열 내의 문자에 접근할 수 있습니다. +"This is a string".charAt(0) + +// null과 undefined도 있습니다. +null // 의도적으로 값이 아님을 나타내는 데 사용합니다. +undefined // 값이 아직 설정되지 않음을 나타내는 데 사용합니다. + +// null, undefinded, NaN, 0, ""은 거짓이며, 그 밖의 다른 모든 값은 참입니다. +// 참고로 0은 거짓이며, "0"은 참입니다(심지어 0 == "0"이더라도). + +/////////////////////////////////// +// 2. 변수, 배열, 객체 + +// 변수는 var 키워드로 선언합니다. 자바스크립트는 동적 타입 언어라서 +// 타입을 지정할 필요가 없습니다. 값을 할당할 때는 = 문자 하나를 사용합니다. +var someVar = 5 + +// var 키워드를 지정하지 않아도 오류는 발생하지 않습니다. +someOtherVar = 10 + +// 그렇지만 변수가 여러분이 정의한 유효범위가 아니라 +// 전역 유효범위에 생성됩니다. + +// 값을 할당하지 않은 채로 선언한 변수는 undefined로 설정됩니다. +var someThirdVar // = undefined + +// 변수에 수학 연산을 수행하는 축약형 표현은 다음과 같습니다. +someVar += 5 // someVar = someVar + 5;와 같음. 이제 someVar는 10. +someVar *= 10 // somVar는 100 + +// 1을 더하거나 빼는 훨씬 더 짧은 표현도 있습니다. +someVar++ // 이제 someVar는 101 +someVar-- // 다시 100으로 되돌아감 + +// 배열은 순차적인 임의 타입 값의 목록입니다. +var myArray = ["Hello", 45, true] + +// 배열의 멤버는 대괄호로 둘러싼 인덱스를 이용해 접근할 수 있습니다. +// 배열의 인덱스는 0부터 시작합니다. +myArray[1] // = 45 + +// 자바스크립트의 객체는 다른 언어의 '사전'이나 '맵'과 같습니다. +// 즉, 키-값 쌍으로 구성된 비순차 컬렉션입니다. +{key1: "Hello", key2: "World"} + +// 키는 문자열이지만 유효한 자바스크립트 식별자일 경우 +// 작은따옴표는 필요하지 않습니다. 값은 어떤 타입이든 사용할 수 있습니다. +var myObj = {myKey: "myValue", "my other key": 4} + +// 객체 속성에도 인덱스를 이용해 접근할 수 있습니다. +myObj["my other key"] // = 4 + +// 또는 키가 유효한 식별자일 경우 점 표기법을 이용해 접근할 수 있습니다. +myObj.myKey // = "myValue" + +// 객체는 변경 가능합니다. 즉, 값을 변경하거나 새 키를 추가할 수 있습니다. +myObj.myThirdKey = true + +// 설정되지 않은 값에 접근하려고 하면 undefined가 반환됩니다. +myObj.myFourthKey // = undefined + +/////////////////////////////////// +// 3. 로직과 제어 구조 + +// if 구조는 여러분이 예상한 대로 동작합니다. +var count = 1 +if (count == 3){ + // count가 3일 경우 평가됨 +} else if (count == 4) { + // count가 4일 경우 평가됨 +} else { + // count가 3이나 4가 아닌 경우에 평가됨 +} + +// while도 마찬가지입니다. +while (true) { + // 무한 루프! +} + +// do-while 문은 항상 최소 한 번은 실행된다는 점을 제외하면 +// while 문과 비슷합니다. +var input +do { + input = getInput() +} while (!isValid(input)) + +// for 문은 C와 자바의 for 문과 같습니다. +// 초기화식; 지속 조건; 증감식 +for (var i = 0; i < 5; i++){ + // 5번 실행됨 +} + +// &&는 논리 and이고 ||는 논리 or입니다. +if (house.size == "big" && house.colour == "blue"){ + house.contains = "bear" +} +if (colour == "red" || colour == "blue"){ + // 색은 빨강이거나 파랑 +} + +// &&와 ||은 "단축 평가"를 수행하는데, 기본값을 설정할 때 유용합니다. +var name = otherName || "default" + +/////////////////////////////////// +// 4. 함수, 유효범위, 클로저 + +// 자바스크립트 함수는 function 키워드로 선언합니다. +function myFunction(thing){ + return thing.toUpperCase() +} +myFunction("foo") // = "FOO" + +// 함수는 "익명"으로, 즉 이름 없이 정의할 수도 있습니다. +function(thing){ + return thing.toLowerCase() +} +// (함수를 가리키는 이름이 없기 때문에 함수를 호출할 수 없습니다) + +// 자바스크립트 함수는 일급 객체이므로 다른 변수에 재할당하고 +// 다른 함수에 인자로 전달할 수 있습니다. 가령, 이벤트 핸들러를 만들 경우 +function myFunction(){ + // 이 코드는 5초 내에 호출됨 +} +setTimeout(myFunction, 5000) + +// 다른 함수를 호출할 때 직접적으로 함수 구문을 작성할 수도 있습니다. + +setTimeout(function myFunction(){ + // 이 코드는 5초 내에 호출됨 +}, 5000) + +// 자바스크립트에는 함수 유효범위가 있습니다. +// 함수는 자체적인 유효범위를 가지지만 다른 블록은 유효범위를 가지지 않습니다. +if (true){ + var i = 5 +} +i // = 5 - 블록 유효범위를 지원하는 언어에서는 undefined가 아닙니다. + +// 이것은 "즉시 실행되는 익명 함수"라는 공통 패턴으로 이어지는데, +// 이 패턴은 임시 변수가 전역 유효범위로 유출되는 것을 방지합니다. +(function(){ + var temporary = 5 + // '전역 객체'에 할당하는 식으로 전역 유효범위에 접근할 수 있는데, + // 브라우저에서 전역 객체는 항상 'window'입니다. 전역 객체는 + // Node.js와 같은 브라우저가 아닌 환경에서는 다른 이름일 수도 있습니다. + window.permanent = 10 + // 또는 앞에서 언급했다시피 var 키워드를 뺄 수도 있습니다. + permanent2 = 15 +})() +temporary // ReferenceError 발생 +permanent // = 10 +permanent2 // = 15 + +// 자바스크립트의 강력한 기능 중 하나는 클로저(closure)입니다. +// 함수가 다른 함수 안에서 정의되면 안쪽에 정의된 함수는 바깥 함수의 +// 모든 변수에 접근할 수 있습니다. +function sayHelloInFiveSeconds(name){ + var prompt = "Hello, " + name + "!" + function inner(){ + alert(prompt) + } + setTimeout(inner, 5000) + // setTimeout은 비동기적으로 동작하므로 이 함수는 5초 동안 + // 기다리지 않고 실행을 마칩니다. 하지만 5초가 지나면 inner에서도 + // prompt의 값에 접근할 수 있습니다. +} +sayHelloInFiveSeconds("Adam") // 5초 내로 "Hello, Adam!"이라고 적힌 팝업이 표시됨 + +/////////////////////////////////// +// 5. 객체 심화; 생성자와 프로토타입 + +// 객체는 함수를 포함할 수 있습니다. +var myObj = { + myFunc: function(){ + return "Hello world!" + } +} +myObj.myFunc() // = "Hello world!" + +// 객체에 포함된 함수가 호출되면 함수에서는 this 키워드를 이용해 +// 해당 함수가 포함된 객체에 접근할 수 있습니다. +myObj = { + myString: "Hello world!", + myFunc: function(){ + return this.myString + } +} +myObj.myFunc() // = "Hello world!" + +// 여기서 설정한 것은 함수가 정의된 곳이 아닌 함수가 호출되는 +// 방식과 관련이 있습니다. 그래서 아래 함수는 객체 컨텍스트에서 +// 호출되지 않으면 동작하지 않습니다. +var myFunc = myObj.myFunc +myFunc() // = undefined + +// 반대로 함수는 객체에 할당하고 this를 통해 해당 객체에 접근할 수 있습니다. +// 함수를 정의할 때 객체에 추가되지 않았더라도 마찬가지입니다. +var myOtherFunc = function(){ + return this.myString.toUpperCase() +} +myObj.myOtherFunc = myOtherFunc +myObj.myOtherFunc() // = "HELLO WORLD!" + +// new 키워드로 함수를 호출하면 새로운 객체가 생성되고 this를 통해 +// 함수에서 사용할 수 있게 됩니다. 이런 식으로 설계된 함수를 생성자라 합니다. + +var MyConstructor = function(){ + this.myNumber = 5 +} +myNewObj = new MyConstructor() // = {myNumber: 5} +myNewObj.myNumber // = 5 + +// 모든 자바스크립트 객체는 'prototype'을 가지고 있습니다. 어떤 객체에 대해 +// 실제 객체에는 존재하지 않는 프로퍼티에 접근하면 인터프리터는 프로로타입에서 +// 해당 프로퍼티를 찾습니다. + +// 일부 자바스크립트 구현체에서는 __proto__라는 마법의 프로퍼티로 +// 객체의 프로토타입에 접근하는 것을 허용하기도 합니다. 프로토타입을 +// 설명하기에는 이런 내용도 도움되겠지만 __proto__는 표준에 포함돼 +// 있지 않습니다. 나중에 프로토타입을 사용하는 표준 방법을 살펴보겠습니다. +var myObj = { + myString: "Hello world!", +} +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +} +myObj.__proto__ = myPrototype +myObj.meaningOfLife // = 42 + +// 이 방법은 함수에도 통합니다. +myObj.myFunc() // = "hello world!" + +// 물론 프로퍼티가 프로토타입에 존재하지 않으면 +// 프로토타입의 프로토타입을 찾는 식으로 진행됩니다. +myPrototype.__proto__ = { + myBoolean: true +} +myObj.myBoolean // = true + +// 여기서 복사는 일어나지 않습니다. 각 객체에는 프로토타입에 대한 +// 참조가 보관돼 있습니다. 이는 프로토타입을 변경하면 변경사항이 +// 모든 곳에 반영된다는 의미입니다. +myPrototype.meaningOfLife = 43 +myObj.meaningOfLife // = 43 + +// 앞에서 __proto__가 표준에 포함돼 있지 않다고 이야기했는데, +// 기존 객체의 프로토타입을 변경하는 표준 방법은 없습니다. +// 하지만 특정 프로토타입을 가지고 새로운 객체를 생성하는 두 가지 +// 방법이 있습니다. + +// 첫 번째 방법은 Object.create를 이용하는 것인데, +// Object.create는 최근에 자바스크립트에 추가된 것이라서 아직까지 +// 모든 구현체에서 이용할 수 있는 것은 아닙니다. +var myObj = Object.create(myPrototype) +myObj.meaningOfLife // = 43 + +// 두 번째 방법은 어디서나 통하는 방법인데, 생성자와 관련이 있습니다. +// 생성자에는 prototype이라는 프로퍼티가 있습니다. 이 프로퍼티는 +// 생성자 함수 자체의 프로토타입이 *아니고* 생성자와 new 키워드를 이용해 +// 객체가 생성될 때 새로운 객체가 받는 프로토타입입니다. +myConstructor.prototype = { + getMyNumber: function(){ + return this.myNumber + } +} +var myNewObj2 = new myConstructor() +myNewObj2.getMyNumber() // = 5 + +// 문자열과 숫자와 같은 내장 타입에도 동등한 래퍼 객체를 +// 생성하는 생성자가 있습니다. +var myNumber = 12 +var myNumberObj = new Number(12) +myNumber == myNumberObj // = true + +// 하지만 정확히 같지는 않습니다. +typeof myNumber // = 'number' +typeof myNumberObj // = 'object' +myNumber === myNumberObj // = false +if (0){ + // 0은 거짓이라서 이 코드는 실행되지 않습니다. +} + +// 하지만 래퍼 객체와 일반 내장 함수는 프로토타입을 공유하기 때문에 +// 가령 문자열에 실제로 기능을 추가할 수 있습니다. +String.prototype.firstCharacter = function(){ + return this.charAt(0) +} +"abc".firstCharacter() // = "a" + +// 이러한 사실은 기존 자바스크립트 버전에서 자바스크립트의 +// 새로운 기능을 구현하는 "폴리필(polyfilling)"에 자주 이용되므로 +// 오래된 버전의 브라우저와 같이 기존 환경에서 사용될 수 있습니다. + +// 예를 들어, Object.create가 모든 구현체에서 사용 가능한 것은 아니라고 +// 했지만 아래의 폴리필을 이용해 Object.create를 여전히 사용할 수 있습니다. +if (Object.create === undefined){ // 이미 존재하면 덮어쓰지 않음 + Object.create = function(proto){ + // 올바른 프로토타입을 가지고 임시 생성자를 만듬 + var Constructor = function(){} + Constructor.prototype = proto + // 그런 다음 임시 생성자를 이용해 새로운 적절한 프로토타입을 + // 포함한 객체를 생성 + return new Constructor() + } +} +``` + +## 기타 참고 자료 + +[모질라 개발자 네트워크](https://developer.mozilla.org/en-US/docs/Web/JavaScript)에서는 +자바스크립트에 대한 훌륭한 문서를 제공합니다. 더불어 위키 형식이라서 좀 더 많은 사항을 +배우게 되면 여러분만의 지식을 공유함으로써 다른 사람들에게 도움을 줄 수도 있습니다. + +MDN의 ['자바스크립트 재입문'](https://developer.mozilla.org/ko/docs/A_re-introduction_to_JavaScript)에서는 +여기서 다룬 개념의 상당수를 더욱 자세히 다루고 있습니다. 이 자료에서는 자바스크립트 언어 자체에 +대해서만 상당히 신중하게 다뤘습니다. 웹 페이지에서 자바스크립트를 사용하는 방법을 배우고 싶다면 +[문서 객체 모델(Document Object Model)](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)에 +관해 배우는 것으로 시작하길 바랍니다. + +[자바스크립트 가든](http://bonsaiden.github.io/JavaScript-Garden/)에서는 자바스크립트 언어에서 +직관에 어긋나는 모든 부분들을 심도 있게 다룹니다. + +더불어 이 글에 직접적으로 기여한 분들로, 내용 중 일부는 이 사이트에 있는 +루이 딘(Louie Dihn)의 파이썬 튜토리얼과 모질라 개발자 네트워크에 있는 +[자바스크립트 튜토리얼](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)을 참고했습니다. diff --git a/ko-kr/lua-kr.html.markdown b/ko-kr/lua-kr.html.markdown new file mode 100644 index 00000000..b4a018ef --- /dev/null +++ b/ko-kr/lua-kr.html.markdown @@ -0,0 +1,422 @@ +--- +language: Lua +category: language +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] +translators: + - ["wikibook", "http://wikibook.co.kr"] +lang: ko-kr +filename: learnlua-kr.lua +--- + +```lua +-- 대시 두 개는 한 줄짜리 주석을 의미합니다. + +--[[ + [와 ]를 두 개씩 추가하면 여러 줄 주석이 됩니다. +--]] + +---------------------------------------------------- +-- 1. 변수와 흐름 제어 +---------------------------------------------------- + +num = 42 -- 모든 숫자는 double입니다. +-- 놀랄 필요는 없습니다. 64비트 double은 +-- 정확한 int 값을 저장하기 위해 52비트로 구성돼 +-- 있습니다. 52비트 이하의 int 값에 대해서는 +-- 장비 정밀도와 관련된 문제가 생기지 않습니다. + +s = 'walternate' -- 파이썬과 같은 불변 문자열 +t = "큰따옴표를 써도 됩니다" +u = [[ 이중 대괄호는 + 여러 줄 문자열을 + 나타냅니다.]] +t = nil -- 미정의 t. 루아는 가비지 컬렉션을 지원합니다. + +-- 블록은 do/end와 같은 키워드로 나타냅니다: +while num < 50 do + num = num + 1 -- ++나 += 유형의 연산자는 쓸 수 없습니다. +end + +-- If 절: +if num > 40 then + print('40 이상') +elseif s ~= 'walternate' then -- ~=은 '같지 않다'입니다. + -- 동일성 검사는 파이썬과 마찬가지로 ==입니다. + -- 문자열에도 쓸 수 있습니다. + io.write('not over 40\n') -- 기본적으로 stdout에 씁니다. +else + -- 변수는 기본적으로 전역 변수입니다. + thisIsGlobal = 5 -- 낙타 표기법이 일반적입니다. + + -- 변수를 지역 변수로 만드는 방법은 다음과 같습니다: + local line = io.read() -- 다음 stdin 줄을 읽습니다 + + -- 문자열 연결에는 .. 연산자를 씁니다: + print('겨울이 오고 있습니다, ' .. line) +end + +-- 미정의 변수는 nil을 반환합니다. +-- 다음 코드를 실행해도 오류가 나지 않습니다: +foo = anUnknownVariable -- 이제 foo는 nil입니다. + +aBoolValue = false + +-- nil과 false만이 거짓값입니다; 0과 ''은 참입니다! +if not aBoolValue then print('twas false') end + +-- 'or'와 'and'는 단축 평가(short-circuit)됩니다. +-- 다음 코드는 C/자바스크립트의 a?b:c 연산자와 비슷합니다: +ans = aBoolValue and 'yes' or 'no' --> 'no' + +karlSum = 0 +for i = 1, 100 do -- 범위에는 마지막 요소도 포함됩니다. + karlSum = karlSum + i +end + +-- 카운트 다운을 할 때는 "100, 1, -1"을 범위로 씁니다. +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- 일반적으로 범위는 begin, end[, step]입니다. + +-- 또 다른 반복문 구문은 다음과 같습니다: +repeat + print('미래의 방식') + num = num - 1 +until num == 0 + + +---------------------------------------------------- +-- 2. 함수 +---------------------------------------------------- + +function fib(n) + if n < 2 then return n end + return fib(n - 2) + fib(n - 1) +end + +-- 클로저와 익명 함수도 사용할 수 있습니다: +function adder(x) + -- 반환된 함수는 adder가 호출될 때 생성되고 x의 + -- 값이 유지됩니다: + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- 반환문, 함수 호출, 할당문은 길이가 다른 +-- 값의 리스트에 대해서도 모두 동작합니다. +-- 리스트에 값이 더 적을 때는 nil이 할당/반환되고 +-- 리스트에 값이 더 많을 때는 나머지 값은 버려집니다. + +x, y, z = 1, 2, 3, 4 +-- 이제 x = 1, y = 2, z = 3이고 4는 버려집니다. + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> "zaphod nil nil"가 출력 +-- 이제 x = 4, y = 8이고 15~42의 값은 버려집니다. + +-- 함수는 일급 객체이고, 지역/전역 유효범위를 가질 +-- 수 있습니다. 아래의 두 함수는 같습니다: +function f(x) return x * x end +f = function (x) return x * x end + +-- 그리고 아래의 두 함수도 마찬가지입니다: +local function g(x) return math.sin(x) end +local g; g = function (x) return math.sin(x) end +-- 'local g'라고 선언하면 g를 지역 함수로 만듭니다. + +-- 그나저나 삼각 함수는 라디안 단위로 동작합니다. + +-- 함수를 호출할 때 문자열 매개변수를 하나만 전달한다면 +-- 괄호를 쓰지 않아도 됩니다: +print 'hello' -- 잘 동작합니다. + + +---------------------------------------------------- +-- 3. 테이블 +---------------------------------------------------- + +-- 테이블 = 루아의 유일한 복합 자료구조로서, 연관 배열입니다. +-- PHP의 배열이나 자바스크립트의 객체와 비슷하며, +-- 리스트로도 사용할 수 있는 해시 기반의 딕셔너리입니다. + +-- 테이블을 딕셔너리/맵으로 사용하기: + +-- 딕셔너리 리터럴은 기본적으로 문자열 키를 가집니다: +t = {key1 = 'value1', key2 = false} + +-- 문자열 키에는 자바스크립트와 유사한 점 표기법을 쓸 수 있습니다: +print(t.key1) -- 'value1'을 출력. +t.newKey = {} -- 새 키/값 쌍을 추가. +t.key2 = nil -- 테이블에서 key2를 제거. + +-- (nil이 아닌) 값을 키로 사용하는 리터럴 표기법: +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- "tau"가 출력 + +-- 키 매칭은 기본적으로 숫자와 문자열에 대해서는 값으로 하지만 +-- 테이블에 대해서는 식별자로 합니다. +a = u['@!#'] -- Now a = 'qbert'. +b = u[{}] -- We might expect 1729, but it's nil: +a = u['@!#'] -- 이제 a는 'qbert'입니다. +b = u[{}] -- 1729를 예상했겠지만 nil입니다: +-- 탐색이 실패하기 때문에 b는 nil입니다. 탐색이 실패하는 이유는 +-- 사용된 키가 원본 값을 저장할 때 사용한 키와 동일한 객체가 아니기 +-- 때문입니다. 따라서 문자열 및 숫자가 좀 더 이식성 있는 키입니다. + +-- 테이블 하나를 매개변수로 취하는 함수를 호출할 때는 괄호가 필요하지 않습니다: +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- 'Sonmi~451'를 출력. + +for key, val in pairs(u) do -- 테이블 순회 + print(key, val) +end + +-- _G는 모든 전역 멤버에 대한 특별한 테이블입니다. +print(_G['_G'] == _G) -- 'true'가 출력 + +-- 테이블을 리스트/배열로 사용하기: + +-- 리스트 리터럴은 암묵적으로 int 키로 설정됩니다: +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v는 리스트 v의 크기입니다. + print(v[i]) -- 인덱스가 1에서 시작합니다!! 제정신이 아닙니다! +end +-- 'list'는 실제 타입이 아닙니다. v는 연속된 정수형 키가 포함된 +-- 테이블이고 리스트로 취급될 뿐입니다. + +---------------------------------------------------- +-- 3.1 메타테이블과 메타메서드 +---------------------------------------------------- + +-- 테이블은 테이블에 연산자 오버로딩을 가능하게 하는 메타테이블을 +-- 가질 수 있습니다. 나중에 메타테이블이 어떻게 자바스크립트 +-- 프로토타입과 같은 행위를 지원하는지 살펴보겠습니다. + +f1 = {a = 1, b = 2} -- 분수 a/b를 표현 +f2 = {a = 2, b = 3} + +-- 다음 코드는 실패합니다: +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- f1의 메타테이블을 대상으로 __add(f1, f2)를 호출 + +-- f1과 f2는 자바스크립트의 프로토타입과 달리 각 메타테이블에 대한 +-- 키가 없어서 getmetatable(f1)과 같이 받아와야 합니다. +-- 메타테이블은 __add 같은 루아가 알고 있는 키가 지정된 일반 테이블입니다. + +-- 그렇지만 다음 줄은 s가 메타테이블을 가지고 있지 않기 때문에 실패합니다. +-- t = s + s +-- 아래와 같이 클래스와 유사한 패턴은 이러한 문제가 발생하지 않습니다. + +-- 메타테이블에 대한 __index는 점을 이용한 탐색을 오버로드합니다: +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- 동작합니다! 고마워요, 메타테이블! + +-- 직접적인 메타테이블 탐색이 실패할 경우 메타테이블의 __index 값을 이용해 +-- 재시도하고, 이런 과정이 반복됩니다. + +-- __index 값은 좀 더 세분화된 탐색을 위해 function(tbl, key)가 +-- 될 수도 있습니다. + +-- __index, __add, ...의 값을 메타메서드라고 합니다. +-- 다음은 메타메서드를 가진 테이블의 전체 목록입니다. + +-- __add(a, b) for a + b +-- __sub(a, b) for a - b +-- __mul(a, b) for a * b +-- __div(a, b) for a / b +-- __mod(a, b) for a % b +-- __pow(a, b) for a ^ b +-- __unm(a) for -a +-- __concat(a, b) for a .. b +-- __len(a) for #a +-- __eq(a, b) for a == b +-- __lt(a, b) for a < b +-- __le(a, b) for a <= b +-- __index(a, b) <fn이나 테이블> for a.b +-- __newindex(a, b, c) for a.b = c +-- __call(a, ...) for a(...) + +---------------------------------------------------- +-- 3.2 클래스 형태의 테이블과 상속 +---------------------------------------------------- + +-- 루아에는 클래스가 내장돼 있지 않으며, 테이블과 메타테이블을 +-- 이용해 클래스를 만드는 다양한 방법이 있습니다. + +-- 다음 예제에 대한 설명은 하단을 참조합니다. + +Dog = {} -- 1. + +function Dog:new() -- 2. + newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('I say ' .. self.sound) +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'I say woof' -- 8. + +-- 1. Dog는 클래스처럼 동작합니다. 실제로는 테이블입니다. +-- 2. function 테이블명:fn(...)은 +-- function 테이블명.fn(self, ...)과 같습니다. +-- :는 self라는 첫 번째 인자를 추가할 뿐입니다. +-- self가 값을 어떻게 얻는지 궁금하다면 아래의 7과 8을 읽어보세요. +-- 3. newObj는 Dog 클래스의 인스턴스가 됩니다. +-- 4. self = 인스턴스화되는 클래스. +-- 주로 self = Dog이지만 상속을 이용하면 이것을 바꿀 수 있습니다. +-- newObj의 메타테이블과 self의 __index를 모두 self에 설정하면 +-- newObj가 self의 함수를 갖게 됩니다. +-- 5. 참고: setmetatable은 첫 번째 인자를 반환합니다. +-- 6. :는 2에서 설명한 것과 같이 동작하지만 이번에는 self가 +-- 클래스가 아닌 인스턴스라고 예상할 수 있습니다. +-- 7. Dog.new(Dog)과 같으므로 new()에서는 self = Dog입니다. +-- 8. mrDog.makeSound(mrDog)과 같으므로 self = mrDog입니다. + +---------------------------------------------------- + +-- 상속 예제: + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + s = self.sound .. ' ' -- 2. + print(s .. s .. s) +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof' -- 4. + +-- 1. LoudDog은 Dog의 메서드와 변수를 갖게 됩니다. +-- 2. self는 new()에서 'sound' 키를 가집니다. 3을 참고하세요. +-- 3. LoudDog.new(LoudDog)과 같고, LoudDog은 'new' 키가 없지만 +-- 메타테이블에서 __index = Dog이기 때문에 Dog.new(LoudDog)으로 +-- 변환됩니다. +-- 결과: seymour의 메타테이블은 LoudDog이고 LoudDog.__index는 +-- LoudDog입니다. 따라서 seymour.key는 seymour.key, +-- LoudDog.key, Dog.key와 같을 것이며, 지정한 키에 어떤 테이블이 +-- 오든 상관없을 것입니다. +-- 4. 'makeSound' 키는 LoudDog에서 발견할 수 있습니다. +-- 이것은 LoudDog.makeSound(seymour)와 같습니다. + +-- 필요할 경우, 하위 클래스의 new()는 기반 클래스의 new()와 유사합니다. +function LoudDog:new() + newObj = {} + -- newObj를 구성 + self.__index = self + return setmetatable(newObj, self) +end + +---------------------------------------------------- +-- 4. 모듈 +---------------------------------------------------- + + +--[[ 여기서 주석을 제거하면 이 스크립트의 나머지 부분은 +-- 실행 가능한 상태가 됩니다. +``` + +```lua +-- mod.lua 파일의 내용이 다음과 같다고 가정해 봅시다. +local M = {} + +local function sayMyName() + print('이소룡') +end + +function M.sayHello() + print('안녕하세요') + sayMyName() +end + +return M + +-- 또 다른 파일에서는 mod.lua의 기능을 이용할 수 있습니다. +local mod = require('mod') -- mod.lua 파일을 실행 + +-- require는 모듈을 포함시키는 표준화된 방법입니다. +-- require는 다음과 같이 동작합니다: (캐싱돼 있지 않을 경우. 하단 참조) +-- mod.lua가 함수의 본문처럼 되므로 mod.lua 안의 지역 멤버는 +-- 밖에서 볼 수 없습니다. + +-- 다음 코드가 동작하는 것은 mod가 mod.lua의 M과 같기 때문입니다. +mod.sayHello() -- 이소룡 씨에게 인사를 건넵니다. + +-- 다음 코드를 실행하면 오류가 발생합니다. +-- sayMyName는 mod.lua 안에서만 존재하기 때문입니다: +mod.sayMyName() -- 오류 + +-- require의 반환값은 캐싱되므로 require를 여러 번 실행해도 +-- 파일은 최대 한 번만 실행됩니다. + +-- mod2.lua에 "print('Hi')"가 들어 있다고 가정해 봅시다. +local a = require('mod2') -- Hi!를 출력 +local b = require('mod2') -- print를 실행하지 않음. a=b + +-- dofile은 require와 비슷하지만 캐싱을 하지 않습니다: +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (require와 달리 다시 한번 실행됨) + +-- loadfile은 루아 파일을 읽어들이지만 실행하지는 않습니다 +f = loadfile('mod2') -- f()를 호출해야 mod2.lua가 실행됩니다. + +-- loadstring은 문자열에 대한 loadfile입니다. +g = loadstring('print(343)') -- 함수를 반환합니다. +g() -- 343이 출력됩니다. 그전까지는 아무것도 출력되지 않습니다. + +--]] + +``` + +## 참고자료 + +루아를 배우는 일이 흥미진진했던 이유는 <a href="http://love2d.org/">Love 2D 게임 엔진</a>을 이용해 +게임을 만들 수 있었기 때문입니다. 이것이 제가 루아를 배운 이유입니다. + +저는 <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV의 "프로그래머를 위한 루아"</a>로 +시작했습니다. 그다음으로 공식 <a href="http://www.lua.org/pil/contents.html">"프로그래밍 루아"</a> 책을 읽었습니다. +그렇게 루아를 배웠습니다. + +lua-users.org에 있는 <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">짧은 루아 레퍼런스</a>를 +읽어두면 도움될지도 모르겠습니다. + +여기서는 표준 라이브러리에 관해서는 다루지 않았습니다. + +* <a href="http://lua-users.org/wiki/StringLibraryTutorial">string 라이브러리</a> +* <a href="http://lua-users.org/wiki/TableLibraryTutorial">table 라이브러리</a> +* <a href="http://lua-users.org/wiki/MathLibraryTutorial">math 라이브러리</a> +* <a href="http://lua-users.org/wiki/IoLibraryTutorial">io 라이브러리</a> +* <a href="http://lua-users.org/wiki/OsLibraryTutorial">os 라이브러리</a> + +그나저나 이 파일 전체는 유효한 루아 프로그램입니다. 이 파일을 +learn.lua로 저장한 후 "lua learn.lua"를 실행해 보세요! + +이 글은 tylerneylon.com에 처음으로 써본 글이며, +<a href="https://gist.github.com/tylerneylon/5853042">Github의 Gist</a>에서도 확인할 수 있습니다. +루아로 즐거운 시간을 보내세요! diff --git a/ko-kr/php-kr.html.markdown b/ko-kr/php-kr.html.markdown new file mode 100644 index 00000000..1f53221f --- /dev/null +++ b/ko-kr/php-kr.html.markdown @@ -0,0 +1,662 @@ +--- +language: PHP +category: language +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +filename: learnphp-kr.php +translators: + - ["wikibook", "http://wikibook.co.kr"] +lang: ko-kr +--- + +이 문서에서는 PHP 5+를 설명합니다. + + +```php +<?php // PHP 코드는 반드시 <?php 태그로 감싸야 합니다. + +// php 파일에 PHP 코드만 들어 있다면 닫는 태그를 생략하는 것이 관례입니다. + +// 슬래시 두 개는 한 줄 주석을 의미합니다. + +# 해시(파운드 기호로도 알려진)도 같은 역할을 하지만 //이 더 일반적으로 쓰입니다. + +/* + 텍스트를 슬래시-별표와 별표-슬래시로 감싸면 + 여러 줄 주석이 만들어집니다. +*/ + +// 출력결과를 표시하려면 "echo"나 "print"를 사용합니다. +print('Hello '); // 줄바꿈 없이 "Hello "를 출력합니다. + +// ()는 print와 echo를 사용할 때 선택적으로 사용할 수 있습니다. +echo "World\n"; // "World"를 출력한 후 줄바꿈합니다. +// (모든 구문은 반드시 세미콜론으로 끝나야 합니다.) + +// <?php 태그 밖의 내용은 모두 자동으로 출력됩니다. +?> +Hello World Again! +<?php + + +/************************************ + * 타입과 변수 + */ + +// 변수명은 $ 기호로 시작합니다. +// 유효한 변수명은 문자나 밑줄(_)로 시작하고, +// 이어서 임의 개수의 숫자나 문자, 밑줄이 옵니다. + +// 불린값은 대소문자를 구분합니다. +$boolean = true; // 또는 TRUE나 True +$boolean = false; // 또는 FALSE나 False + +// Integer +$int1 = 12; // => 12 +$int2 = -12; // => -12 +$int3 = 012; // => 10 (a leading 0 denotes an octal number) +$int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal) + +// Float (doubles로도 알려짐) +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// 산술 연산 +$sum = 1 + 1; // 2 +$difference = 2 - 1; // 1 +$product = 2 * 2; // 4 +$quotient = 2 / 1; // 2 + +// 축약형 산술 연산 +$number = 0; +$number += 1; // $number를 1만큼 증가 +echo $number++; // 1을 출력(평가 후 증가) +echo ++$number; // 3 (평가 전 증가) +$number /= $float; // 나눗셈 후 몫을 $number에 할당 + +// 문자열은 작은따옴표로 감싸야 합니다. +$sgl_quotes = '$String'; // => '$String' + +// 다른 변수를 포함할 때를 제외하면 큰따옴표 사용을 자제합니다. +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' + +// 특수 문자는 큰따옴표에서만 이스케이프됩니다. +$escaped = "This contains a \t tab character."; +$unescaped = 'This just contains a slash and a t: \t'; + +// 필요할 경우 변수를 중괄호로 감쌉니다. +$money = "I have $${number} in the bank."; + +// PHP 5.3부터는 여러 줄 문자열을 생성하는 데 나우닥(nowdoc)을 사용할 수 있습니다. +$nowdoc = <<<'END' +Multi line +string +END; + +// 히어닥(heredoc)에서는 문자열 치환을 지원합니다. +$heredoc = <<<END +Multi line +$sgl_quotes +END; + +// 문자열을 연결할 때는 .을 이용합니다. +echo 'This string ' . 'is concatenated'; + + +/******************************** + * 상수 + */ + +// 상수는 define()을 이용해 정의되며, +// 런타임 동안 절대 변경될 수 없습니다! + +// 유효한 상수명은 문자나 밑줄로 시작하고, +// 이어서 임의 개수의 숫자나 문자, 밑줄이 옵니다. +define("FOO", "something"); + +// 상수명을 이용해 직접 상수에 접근할 수 있습니다. +echo 'This outputs '.FOO; + + +/******************************** + * 배열 + */ + +// PHP의 모든 배열은 연관 배열(associative array, 해시맵)입니다. + +// 일부 언어에서 해시맵으로도 알려진 연관 배열은 + +// 모든 PHP 버전에서 동작합니다. +$associative = array('One' => 1, 'Two' => 2, 'Three' => 3); + +// PHP 5.4에서는 새로운 문법이 도입됐습니다. +$associative = ['One' => 1, 'Two' => 2, 'Three' => 3]; + +echo $associative['One']; // 1을 출력 + +// 리스트 리터럴은 암시적으로 정수형 키를 할당합니다. +$array = ['One', 'Two', 'Three']; +echo $array[0]; // => "One" + + +/******************************** + * 출력 + */ + +echo('Hello World!'); +// 표준출력(stdout)에 Hello World!를 출력합니다. +// 브라우저에서 실행할 경우 표준출력은 웹 페이지입니다. + +print('Hello World!'); // echo과 동일 + +// echo는 실제로 언어 구성물에 해당하므로, 괄호를 생략할 수 있습니다. +echo 'Hello World!'; +print 'Hello World!'; // 똑같이 출력됩니다. + +$paragraph = 'paragraph'; + +echo 100; // 스칼라 변수는 곧바로 출력합니다. +echo $paragraph; // 또는 변수의 값을 출력합니다. + +// 축약형 여는 태그를 설정하거나 PHP 버전이 5.4.0 이상이면 +// 축약된 echo 문법을 사용할 수 있습니다. +?> +<p><?= $paragraph ?></p> +<?php + +$x = 1; +$y = 2; +$x = $y; // 이제 $x의 값은 $y의 값과 같습니다. +$z = &$y; +// $z는 이제 $y에 대한 참조를 담고 있습니다. $z의 값을 변경하면 +// $y의 값도 함께 변경되며, 그 반대도 마찬가지입니다. +// $x는 $y의 원래 값을 그대로 유지합니다. + +echo $x; // => 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 + + +/******************************** + * 로직 + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; + +// assert는 인자가 참이 아닌 경우 경고를 출력합니다. + +// 다음과 같은 비교는 항상 참이며, 타입이 같지 않더라도 마찬가지입니다. +assert($a == $b); // 동일성 검사 +assert($c != $a); // 불일치성 검사 +assert($c <> $a); // 또 다른 불일치성 검사 +assert($a < $c); +assert($c > $b); +assert($a <= $b); +assert($c >= $d); + +// 다음과 같은 코드는 값과 타입이 모두 일치하는 경우에만 참입니다. +assert($c === $d); +assert($a !== $d); +assert(1 == '1'); +assert(1 !== '1'); + +// 변수는 어떻게 사용하느냐 따라 다른 타입으로 변환될 수 있습니다. + +$integer = 1; +echo $integer + $integer; // => 2 + +$string = '1'; +echo $string + $string; // => 2 (문자열이 강제로 정수로 변환됩니다) + +$string = 'one'; +echo $string + $string; // => 0 +// + 연산자는 'one'이라는 문자열을 숫자로 형변환할 수 없기 때문에 0이 출력됩니다. + +// 한 변수를 다른 타입으로 처리하는 데 형변환을 사용할 수 있습니다. + +$boolean = (boolean) 1; // => true + +$zero = 0; +$boolean = (boolean) $zero; // => false + +// 대다수의 타입을 형변환하는 데 사용하는 전용 함수도 있습니다. +$integer = 5; +$string = strval($integer); + +$var = null; // 널 타입 + + +/******************************** + * 제어 구조 + */ + +if (true) { + print 'I get printed'; +} + +if (false) { + print 'I don\'t'; +} else { + print 'I get printed'; +} + +if (false) { + print 'Does not get printed'; +} elseif(true) { + print 'Does'; +} + +// 사항 연산자 +print (false ? 'Does not get printed' : 'Does'); + +$x = 0; +if ($x === '0') { + print 'Does not print'; +} elseif($x == '1') { + print 'Does not print'; +} else { + print 'Does print'; +} + + + +// 다음과 같은 문법은 템플릿에 유용합니다. +?> + +<?php if ($x): ?> +This is displayed if the test is truthy. +<?php else: ?> +This is displayed otherwise. +<?php endif; ?> + +<?php + +// 특정 로직을 표현할 때는 switch를 사용합니다. +switch ($x) { + case '0': + print 'Switch does type coercion'; + break; // break을 반드시 포함해야 하며, break를 생략하면 + // 'two'와 'three' 케이스로 넘어갑니다. + case 'two': + case 'three': + // 변수가 'two'나 'three'인 경우에 실행될 코드를 작성합니다. + break; + default: + // 기본값으로 실행될 코드를 작성 +} + +// while과 do...while, for 문이 아마 더 친숙할 것입니다. +$i = 0; +while ($i < 5) { + echo $i++; +}; // "01234"를 출력 + +echo "\n"; + +$i = 0; +do { + echo $i++; +} while ($i < 5); // "01234"를 출력 + +echo "\n"; + +for ($x = 0; $x < 10; $x++) { + echo $x; +} // "0123456789"를 출력 + +echo "\n"; + +$wheels = ['bicycle' => 2, 'car' => 4]; + +// foreach 문은 배영를 순회할 수 있습니다. +foreach ($wheels as $wheel_count) { + echo $wheel_count; +} // "24"를 출력 + +echo "\n"; + +// 키와 값을 동시에 순회할 수 있습니다. +foreach ($wheels as $vehicle => $wheel_count) { + echo "A $vehicle has $wheel_count wheels"; +} + +echo "\n"; + +$i = 0; +while ($i < 5) { + if ($i === 3) { + break; // while 문을 빠져나옴 + } + echo $i++; +} // "012"를 출력 + +for ($i = 0; $i < 5; $i++) { + if ($i === 3) { + continue; // 이번 순회를 생략 + } + echo $i; +} // "0124"를 출력 + + +/******************************** + * 함수 + */ + +// "function"으로 함수를 정의합니다. +function my_function () { + return 'Hello'; +} + +echo my_function(); // => "Hello" + +// 유효한 함수명은 문자나 밑줄로 시작하고, 이어서 +// 임의 개수의 문자나 숫자, 밑줄이 옵니다. + +function add ($x, $y = 1) { // $y는 선택사항이고 기본값은 1입니다. + $result = $x + $y; + return $result; +} + +echo add(4); // => 5 +echo add(4, 2); // => 6 + +// 함수 밖에서는 $result에 접근할 수 없습니다. +// print $result; // 이 코드를 실행하면 경고가 출력됩니다. + +// PHP 5.3부터는 익명 함수를 선언할 수 있습니다. +$inc = function ($x) { + return $x + 1; +}; + +echo $inc(2); // => 3 + +function foo ($x, $y, $z) { + echo "$x - $y - $z"; +} + +// 함수에서는 함수를 반환할 수 있습니다. +function bar ($x, $y) { + // 'use'를 이용해 바깥 함수의 변수를 전달합니다. + return function ($z) use ($x, $y) { + foo($x, $y, $z); + }; +} + +$bar = bar('A', 'B'); +$bar('C'); // "A - B - C"를 출력 + +// 문자열을 이용해 이름이 지정된 함수를 호출할 수 있습니다. +$function_name = 'add'; +echo $function_name(1, 2); // => 3 +// 프로그램 방식으로 어느 함수를 실행할지 결정할 때 유용합니다. +// 아니면 call_user_func(callable $callback [, $parameter [, ... ]]);를 사용해도 됩니다. + +/******************************** + * 인클루드 + */ + +<?php +// 인클루드된 파일 내의 PHP 코드도 반드시 PHP 여는 태그로 시작해야 합니다. + +include 'my-file.php'; +// my-file.php 안의 코드는 이제 현재 유효범위에서 이용할 수 있습니다. +// 파일을 인클루드할 수 없으면(예: 파일을 찾을 수 없음) 경고가 출력됩니다. + +include_once 'my-file.php'; +// my-file.php 안의 코드가 다른 곳에 인클루드됐다면 다시 인클루드되지는 않습니다. +// 따라서 클래스 선언이 여러 번 되어 발생하는 문제가 일어나지 않습니다. + +require 'my-file.php'; +require_once 'my-file.php'; +// require()는 include()와 같지만 파일을 인클루드할 수 없을 경우 +// 치명적인 오류가 발생한다는 점이 다릅니다. + +// my-include.php의 내용 +<?php + +return 'Anything you like.'; +// 파일의 끝 + +// include와 require는 값을 반환할 수도 있습니다. +$value = include 'my-include.php'; + +// 파일은 지정된 파일 경로를 토대로 인클루드되거나, 혹은 아무것도 명시하지 않은 경우 +// include_path라는 설정 지시지를 따릅니다. include_path에서 파일을 발견할 수 없으면 +// include는 마지막으로 실패하기 전에 호출 스크립트 자체의 디렉터리와 현재 작업 디렉터리를 확인합니다. +/* */ + +/******************************** + * 클래스 + */ + +// 클래스는 class라는 키워드로 정의합니다. + +class MyClass +{ + const MY_CONST = 'value'; // 상수 + + static $staticVar = 'static'; + + // 프로퍼티에는 반드시 가시성을 선언해야 합니다. + public $property = 'public'; + public $instanceProp; + protected $prot = 'protected'; // 이 클래스와 하위 클래스에서 접근할 수 있음 + private $priv = 'private'; // 이 클래스 내에서만 접근 가능 + + // __construct로 생성자를 만듭니다. + public function __construct($instanceProp) { + // $this로 인스턴스 변수에 접근합니다. + $this->instanceProp = $instanceProp; + } + + // 메서드는 클래스 안의 함수로서 선언됩니다. + public function myMethod() + { + print 'MyClass'; + } + + final function youCannotOverrideMe() + { + } + + public static function myStaticMethod() + { + print 'I am static'; + } +} + +echo MyClass::MY_CONST; // 'value' 출력 +echo MyClass::$staticVar; // 'static' 출력 +MyClass::myStaticMethod(); // 'I am static' 출력 + +// new를 사용해 클래스를 인스턴스화합니다. +$my_class = new MyClass('An instance property'); +// 인자를 전달하지 않을 경우 괄호를 생략할 수 있습니다. + +// ->를 이용해 클래스 멤버에 접근합니다 +echo $my_class->property; // => "public" +echo $my_class->instanceProp; // => "An instance property" +$my_class->myMethod(); // => "MyClass" + + +// "extends"를 이용해 클래스를 확장합니다. +class MyOtherClass extends MyClass +{ + function printProtectedProperty() + { + echo $this->prot; + } + + // 메서드 재정의 + function myMethod() + { + parent::myMethod(); + print ' > MyOtherClass'; + } +} + +$my_other_class = new MyOtherClass('Instance prop'); +$my_other_class->printProtectedProperty(); // => "protected" 출력 +$my_other_class->myMethod(); // "MyClass > MyOtherClass" 출력 + +final class YouCannotExtendMe +{ +} + +// "마법 메서드(magic method)"로 설정자 메서드와 접근자 메서드를 만들 수 있습니다. +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; // __get() 메서드를 사용 +$x->property = 'Something'; // __set() 메서드를 사용 + +// 클래스는 추상화하거나(abstract 키워드를 사용해) +// 인터페이스를 구현할 수 있습니다(implments 키워드를 사용해). +// 인터페이스는 interface 키워드로 선언합니다. + +interface InterfaceOne +{ + public function doSomething(); +} + +interface InterfaceTwo +{ + public function doSomethingElse(); +} + +// 인터페이스는 확장할 수 있습니다. +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'; + } +} + + +// 클래스에서는 하나 이상의 인터페이스를 구현할 수 있습니다. +class SomeOtherClass implements InterfaceOne, InterfaceTwo +{ + public function doSomething() + { + echo 'doSomething'; + } + + public function doSomethingElse() + { + echo 'doSomethingElse'; + } +} + + +/******************************** + * 특성 + */ + +// 특성(trait)은 PHP 5.4.0부터 사용 가능하며, "trait"으로 선언합니다. + +trait MyTrait +{ + public function myTraitMethod() + { + print 'I have MyTrait'; + } +} + +class MyTraitfulClass +{ + use MyTrait; +} + +$cls = new MyTraitfulClass(); +$cls->myTraitMethod(); // "I have MyTrait"을 출력 + + +/******************************** + * 네임스페이스 + */ + +// 이 부분은 별도의 영역인데, 파일에서 처음으로 나타나는 문장은 +// 네임스페이스 선언이어야 하기 때문입니다. 여기서는 그런 경우가 아니라고 가정합니다. + +<?php + +// 기본적으로 클래스는 전역 네임스페이스에 존재하며, +// 백슬래시를 이용해 명시적으로 호출할 수 있습니다. + +$cls = new \MyClass(); + + + +// 파일에 대한 네임스페이스를 설정합니다. +namespace My\Namespace; + +class MyClass +{ +} + +// (다른 파일에 들어 있는 코드) +$cls = new My\Namespace\MyClass; + +// 또는 다른 네임스페이스 내에서 접근하는 경우 +namespace My\Other\Namespace; + +use My\Namespace\MyClass; + +$cls = new MyClass(); + +// 혹은 네임스페이스에 별칭을 붙일 수도 있습니다. + +namespace My\Other\Namespace; + +use My\Namespace as SomeOtherNamespace; + +$cls = new SomeOtherNamespace\MyClass(); + +*/ + +``` + +## 더 자세한 정보 + +레퍼런스와 커뮤니티 관련 내용은 [공식 PHP 문서](http://www.php.net/manual/)를 참고하세요. + +최신 모범 사례에 관심이 있다면 [PHP The Right Way](http://www.phptherightway.com/)를 참고하세요. + +PHP를 익히기 전에 다른 훌륭한 패키지 관리자를 지원하는 언어를 사용해본 적이 있다면 [컴포저(Composer)](http://getcomposer.org/)를 확인해 보세요. + +공통 표준이 궁금하다면 PHP 프레임워크 상호운용성 그룹의 [PSR 표준](https://github.com/php-fig/fig-standards)을 참고하세요. diff --git a/ko-kr/python-kr.html.markdown b/ko-kr/python-kr.html.markdown new file mode 100644 index 00000000..ed377a99 --- /dev/null +++ b/ko-kr/python-kr.html.markdown @@ -0,0 +1,484 @@ +--- +language: python +category: language +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +filename: learnpython-ko.py +translators: + - ["wikibook", "http://wikibook.co.kr"] +lang: ko-kr +--- + +파이썬은 귀도 반 로섬이 90년대에 만들었습니다. 파이썬은 현존하는 널리 사용되는 언어 중 하나입니다. +저는 문법적 명료함에 반해 파이썬을 사랑하게 됐습니다. 파이썬은 기본적으로 실행 가능한 의사코드입니다. + +피드백 주시면 정말 감사하겠습니다! [@louiedinh](http://twitter.com/louiedinh)나 +louiedinh [at] [구글의 이메일 서비스]를 통해 저에게 연락하시면 됩니다. + +참고: 이 글은 구체적으로 파이썬 2.7에 해당하는 내용을 담고 있습니다만 +파이썬 2.x에도 적용할 수 있을 것입니다. 파이썬 3을 다룬 튜토리얼도 곧 나올 테니 기대하세요! + +```python +# 한 줄짜리 주석은 해시로 시작합니다. +""" 여러 줄 문자열은 "를 세 개 써서 시작할 수 있고, + 주석으로 자주 사용됩니다. +""" + +#################################################### +## 1. 기본 자료형과 연산자 +#################################################### + +# 숫자 +3 #=> 3 + +# 수학 연산은 예상하신 대로입니다. +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# 나눗셈은 약간 까다롭습니다. 정수로 나눈 다음 결과값을 자동으로 내림합니다. +5 / 2 #=> 2 + +# 나눗셈 문제를 해결하려면 float에 대해 알아야 합니다. +2.0 # 이것이 float입니다. +11.0 / 4.0 #=> 2.75 훨씬 낫네요 + +# 괄호를 이용해 연산자 우선순위를 지정합니다. +(1 + 3) * 2 #=> 8 + +# 불린(Boolean) 값은 기본형입니다. +True +False + +# not을 이용해 부정합니다. +not True #=> False +not False #=> True + +# 동일성 연산자는 ==입니다. +1 == 1 #=> True +2 == 1 #=> False + +# 불일치 연산자는 !=입니다. +1 != 1 #=> False +2 != 1 #=> True + +# 그밖의 비교 연산자는 다음과 같습니다. +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# 비교 연산을 연결할 수도 있습니다! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# 문자열은 "나 '로 생성합니다. +"This is a string." +'This is also a string.' + +# 문자열도 연결할 수 있습니다! +"Hello " + "world!" #=> "Hello world!" + +# 문자열은 문자로 구성된 리스트로 간주할 수 있습니다. +"This is a string"[0] #=> 'T' + +# %는 다음과 같이 문자열을 형식화하는 데 사용할 수 있습니다: +"%s can be %s" % ("strings", "interpolated") + +# 문자열을 형식화하는 새로운 방법은 format 메서드를 이용하는 것입니다. +# 이 메서드를 이용하는 방법이 더 선호됩니다. +"{0} can be {1}".format("strings", "formatted") +# 자릿수를 세기 싫다면 키워드를 이용해도 됩니다. +"{name} wants to eat {food}".format(name="Bob", food="lasagna") + +# None은 객체입니다. +None #=> None + +# 객체와 None을 비교할 때는 동일성 연산자인 `==`를 사용해서는 안 됩니다. +# 대신 `is`를 사용하세요. +"etc" is None #=> False +None is None #=> True + +# 'is' 연산자는 객체의 식별자를 검사합니다. +# 기본형 값을 다룰 때는 이 연산자가 그다지 유용하지 않지만 +# 객체를 다룰 때는 매우 유용합니다. + +# None, 0, 빈 문자열/리스트는 모두 False로 평가됩니다. +# 그밖의 다른 값은 모두 True입니다 +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. 변수와 컬렉션 +#################################################### + +# 뭔가를 출력하는 것은 상당히 쉽습니다. +print "I'm Python. Nice to meet you!" + + +# 변수에 값을 할당하기 전에 변수를 반드시 선언하지 않아도 됩니다. +some_var = 5 # 명명관례는 '밑줄이_포함된_소문자'입니다. +some_var #=> 5 + +# 미할당된 변수에 접근하면 예외가 발생합니다. +# 예외 처리에 관해서는 '제어 흐름'을 참고하세요. +some_other_var # 이름 오류가 발생 + +# 표현식으로도 사용할 수 있습니다. +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# 리스트는 순차 항목을 저장합니다. +li = [] +# 미리 채워진 리스트로 시작할 수도 있습니다. +other_li = [4, 5, 6] + +# append를 이용해 리스트 끝에 항목을 추가합니다. +li.append(1) #li는 이제 [1]입니다. +li.append(2) #li는 이제 [1, 2]입니다. +li.append(4) #li는 이제 [1, 2, 4]입니다. +li.append(3) #li는 이제 [1, 2, 4, 3]입니다. +# pop을 이용해 끝에서부터 항목을 제거합니다. +li.pop() #=> 3이 반환되고 li는 이제 [1, 2, 4]입니다. +# 다시 넣어봅시다 +li.append(3) # li는 이제 다시 [1, 2, 4, 3]가 됩니다. + +# 배열에서 했던 것처럼 리스트에도 접근할 수 있습니다. +li[0] #=> 1 +# 마지막 요소를 봅시다. +li[-1] #=> 3 + +# 범위를 벗어나서 접근하면 IndexError가 발생합니다. +li[4] # IndexError가 발생 + +# 슬라이스 문법을 통해 범위를 지정해서 값을 조회할 수 있습니다. +# (이 문법을 통해 간편하게 범위를 지정할 수 있습니다.) +li[1:3] #=> [2, 4] +# 앞부분을 생략합니다. +li[2:] #=> [4, 3] +# 끝부분을 생략합니다. +li[:3] #=> [1, 2, 4] + +# del로 임의의 요소를 제거할 수 있습니다. +del li[2] # li is now [1, 2, 3] + +# 리스트를 추가할 수도 있습니다. +li + other_li #=> [1, 2, 3, 4, 5, 6] - 참고: li와 other_li는 그대로 유지됩니다. + +# extend로 리스트를 연결합니다. +li.extend(other_li) # 이제 li는 [1, 2, 3, 4, 5, 6]입니다. + +# in으로 리스트 안에서 특정 요소가 존재하는지 확인합니다. +1 in li #=> True + +# len으로 길이를 검사합니다. +len(li) #=> 6 + +# 튜플은 리스트와 비슷하지만 불변성을 띱니다. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # TypeError가 발생 + +# 튜플에 대해서도 리스트에서 할 수 있는 일들을 모두 할 수 있습니다. +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# 튜플(또는 리스트)을 변수로 풀 수 있습니다. +a, b, c = (1, 2, 3) # 이제 a는 1, b는 2, c는 3입니다 +# 괄호를 빼면 기본적으로 튜플이 만들어집니다. +d, e, f = 4, 5, 6 +# 이제 두 값을 바꾸는 게 얼마나 쉬운지 확인해 보세요. +e, d = d, e # 이제 d는 5이고 e는 4입니다. + +# 딕셔너리는 매핑을 저장합니다. +empty_dict = {} +# 다음은 값을 미리 채운 딕셔너리입니다. +filled_dict = {"one": 1, "two": 2, "three": 3} + +# []를 이용해 값을 조회합니다. +filled_dict["one"] #=> 1 + +# 모든 키를 리스트로 구합니다. +filled_dict.keys() #=> ["three", "two", "one"] +# 참고 - 딕셔너리 키의 순서는 보장되지 않습니다. +# 따라서 결과가 이와 정확히 일치하지 않을 수도 있습니다. + +# 모든 값을 리스트로 구합니다. +filled_dict.values() #=> [3, 2, 1] +# 참고 - 키 순서와 관련해서 위에서 설명한 내용과 같습니다. + +# in으로 딕셔너리 안에 특정 키가 존재하는지 확인합니다. +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# 존재하지 않는 키를 조회하면 KeyError가 발생합니다. +filled_dict["four"] # KeyError + +# get 메서드를 이용하면 KeyError가 발생하지 않습니다. +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# get 메서드는 값이 누락된 경우 기본 인자를 지원합니다. +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# setdefault 메서드는 딕셔너리에 새 키-값 쌍을 추가하는 안전한 방법입니다. +filled_dict.setdefault("five", 5) #filled_dict["five"]는 5로 설정됩니다. +filled_dict.setdefault("five", 6) #filled_dict["five"]는 여전히 5입니다. + + +# 세트는 집합을 저장합니다. +empty_set = set() +# 다수의 값으로 세트를 초기화합니다. +some_set = set([1,2,2,3,4]) # 이제 some_set는 set([1, 2, 3, 4])입니다. + +# 파이썬 2.7부터는 {}를 세트를 선언하는 데 사용할 수 있습니다. +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# 세트에 항목을 추가합니다. +filled_set.add(5) # 이제 filled_set는 {1, 2, 3, 4, 5}입니다. + +# &을 이용해 교집합을 만듭니다. +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# |를 이용해 합집합을 만듭니다. +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# -를 이용해 차집합을 만듭니다. +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# in으로 세트 안에 특정 요소가 존재하는지 검사합니다. +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. 제어 흐름 +#################################################### + +# 변수를 만들어 봅시다. +some_var = 5 + +# 다음은 if 문입니다. 파이썬에서는 들여쓰기가 대단히 중요합니다! +# 다음 코드를 실행하면 "some_var is smaller than 10"가 출력됩니다. +if some_var > 10: + print "some_var is totally bigger than 10." +elif some_var < 10: # elif 절은 선택사항입니다. + print "some_var is smaller than 10." +else: # 이 부분 역시 선택사항입니다. + print "some_var is indeed 10." + + +""" +for 루프는 리스트를 순회합니다. +아래 코드는 다음과 같은 내용을 출력합니다: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + # %로 형식화된 문자열에 값을 채워넣을 수 있습니다. + print "%s is a mammal" % animal + +""" +`range(number)`는 숫자 리스트를 반환합니다. +이때 숫자 리스트의 범위는 0에서 지정한 숫자까지입니다. +아래 코드는 다음과 같은 내용을 출력합니다: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +while 루프는 조건이 더는 충족되지 않을 때까지 진행됩니다. +prints: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # x = x + 1의 축약형 + +# try/except 블록을 이용한 예외 처리 + +# 파이썬 2.6 및 상위 버전에서 동작하는 코드 +try: + # raise를 이용해 오류를 발생시킵니다 + raise IndexError("This is an index error") +except IndexError as e: + pass # pass는 단순 no-op 연산입니다. 보통 이곳에 복구 코드를 작성합니다. + + +#################################################### +## 4. 함수 +#################################################### + +# 새 함수를 만들 때 def를 사용합니다. +def add(x, y): + print "x is %s and y is %s" % (x, y) + return x + y # return 문을 이용해 값을 반환합니다. + +# 매개변수를 전달하면서 함수를 호출 +add(5, 6) #=> "x is 5 and y is 6"가 출력되고 11이 반환됨 + +# 함수를 호출하는 또 다른 방법은 키워드 인자를 지정하는 방법입니다. +add(y=6, x=5) # 키워드 인자는 순서에 구애받지 않습니다. + +# 위치 기반 인자를 임의 개수만큼 받는 함수를 정의할 수 있습니다. +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# 키워드 인자를 임의 개수만큼 받는 함수 또한 정의할 수 있습니다. +def keyword_args(**kwargs): + return kwargs + +# 이 함수를 호출해서 어떤 일이 일어나는지 확인해 봅시다. +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# 원한다면 한 번에 두 가지 종류의 인자를 모두 받는 함수를 정의할 수도 있습니다. +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4)를 실행하면 다음과 같은 내용이 출력됩니다: + (1, 2) + {"a": 3, "b": 4} +""" + +# 함수를 호출할 때 varargs/kwargs와 반대되는 일을 할 수 있습니다! +# *를 이용해 튜플을 확장하고 **를 이용해 kwargs를 확장합니다. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # foo(1, 2, 3, 4)와 같음 +all_the_args(**kwargs) # foo(a=3, b=4)와 같음 +all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4)와 같음 + +# 파이썬에는 일급 함수가 있습니다 +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# 게다가 익명 함수도 있습니다. +(lambda x: x > 2)(3) #=> True + +# 내장된 고차 함수(high order function)도 있습니다. +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# 맵과 필터에 리스트 조건 제시법(list comprehensions)을 사용할 수 있습니다. +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. 클래스 +#################################################### + +# 클래스를 하나 만들기 위해 특정 객체의 하위 클래스를 만들 수 있습니다. +class Human(object): + + # 클래스 속성은 이 클래스의 모든 인스턴스에서 공유합니다. + species = "H. sapiens" + + # 기본 초기화자 + def __init__(self, name): + # 인자를 인스턴스의 name 속성에 할당합니다. + self.name = name + + # 모든 인스턴스 메서드에서는 self를 첫 번째 인자로 받습니다. + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # 클래스 메서드는 모든 인스턴스에서 공유합니다. + # 클래스 메서드는 호출하는 클래스를 첫 번째 인자로 호출됩니다. + @classmethod + def get_species(cls): + return cls.species + + # 정적 메서드는 클래스나 인스턴스 참조 없이도 호출할 수 있습니다. + @staticmethod + def grunt(): + return "*grunt*" + + +# 클래스 인스턴스화 +i = Human(name="Ian") +print i.say("hi") # "Ian: hi"가 출력됨 + +j = Human("Joel") +print j.say("hello") # "Joel: hello"가 출력됨 + +# 클래스 메서드를 호출 +i.get_species() #=> "H. sapiens" + +# 공유 속성을 변경 +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# 정적 메서드를 호출 +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. 모듈 +#################################################### + +# 다음과 같이 모듈을 임포트할 수 있습니다. +import math +print math.sqrt(16) #=> 4 + +# 모듈의 특정 함수를 호출할 수 있습니다. +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# 모듈의 모든 함수를 임포트할 수 있습니다. +# Warning: this is not recommended +from math import * + +# 모듈 이름을 축약해서 쓸 수 있습니다. +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# 파이썬 모듈은 평범한 파이썬 파일에 불과합니다. +# 직접 모듈을 작성해서 그것들을 임포트할 수 있습니다. +# 모듈의 이름은 파일의 이름과 같습니다. + +# 다음과 같은 코드로 모듈을 구성하는 함수와 속성을 확인할 수 있습니다. +import math +dir(math) + + +``` + +## 더 배울 준비가 되셨습니까? + +### 무료 온라인 참고자료 + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### 파이썬 관련 도서 + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/ko-kr/racket-kr.html.markdown b/ko-kr/racket-kr.html.markdown new file mode 100644 index 00000000..8d830279 --- /dev/null +++ b/ko-kr/racket-kr.html.markdown @@ -0,0 +1,640 @@ +--- + +language: racket +filename: learnracket-kr.rkt +contributors: + - ["th3rac25", "https://github.com/voila"] + - ["Eli Barzilay", "https://github.com/elibarzilay"] + - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"] + - ["Duong H. Nguyen", "https://github.com/cmpitg"] +translators: + - ["KIM Taegyoon", "https://github.com/kimtg"] +lang: ko-kr +--- + +Racket 은 Lisp/Scheme 계열의 일반 목적의, 다중 패러다임 프로그래밍 언어이다. + +```racket +#lang racket ; 우리가 사용하는 언어를 정의한다. + +;;; 주석 + +;; 한 줄 주석은 세미콜론으로 시작한다. + +#| 블록 주석 + 은 여러 줄에 걸칠 수 있으며... + #| + 중첩될 수 있다! + |# +|# + +;; S-expression 주석은 아래 식을 버리므로, +;; 디버깅할 때 식을 주석화할 때 유용하다. +#; (이 식은 버려짐) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. 근본 자료형과 연산자 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 숫자 +9999999999999999999999 ; 정수 +#b111 ; 이진수 => 7 +#o111 ; 팔진수 => 73 +#x111 ; 16진수 => 273 +3.14 ; 실수 +6.02e+23 +1/2 ; 분수 +1+2i ; 복소수 + +;; 함수 적용은 이렇게 쓴다: (f x y z ...) +;; 여기에서 f는 함수이고 x, y, z는 피연산자이다. +;; 글자 그대로의 데이터 리스트를 만들고 싶다면 평가를 막기 위해 '를 쓰시오. +'(+ 1 2) ; => (+ 1 2) +;; 이제, 산술 연산 몇 개 +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(quotient 5 2) ; => 2 +(remainder 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(exact->inexact 1/3) ; => 0.3333333333333333 +(+ 1+2i 2-3i) ; => 3-1i + +;;; 불린 +#t ; 참 +#f ; 거짓 -- #f가 아닌 것은 참 +(not #t) ; => #f +(and 0 #f (error "doesn't get here")) ; => #f +(or #f 0 (error "doesn't get here")) ; => 0 + +;;; 문자 +#\A ; => #\A +#\λ ; => #\λ +#\u03BB ; => #\λ + +;;; 문자열은 고정 길이의 문자 배열이다. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; 백슬래시는 탈출 문자이다. +"Foo\tbar\41\x21\u0021\a\r\n" ; C 탈출 문자, 유니코드 포함 +"λx:(μα.α→α).xx" ; 유니코드 문자 포함 가능 + +;; 문자열은 붙여질 수 있다! +(string-append "Hello " "world!") ; => "Hello world!" + +;; 문자열은 문자의 리스트처럼 취급될 수 있다. +(string-ref "Apple" 0) ; => #\A + +;; format은 문자열을 형식화하기 위해 사용된다: +(format "~a can be ~a" "strings" "formatted") + +;; 인쇄는 쉽다. +(printf "I'm Racket. Nice to meet you!\n") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. 변수 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; define으로 변수를 만든다. +;; 변수명으로 다음 문자를 사용할 수 없다: ()[]{}",'`;#|\ +(define some-var 5) +some-var ; => 5 + +;; 유니코드 문자도 사용 가능하다. +(define ⊆ subset?) +(⊆ (set 3 2) (set 1 2 3)) ; => #t + +;; 앞에서 정의되지 않은 변수에 접근하면 예외가 발생한다. +; x ; => x: undefined ... + +;; 지역 변수: `me'는 (let ...) 안에서만 "Bob"이다. +(let ([me "Bob"]) + "Alice" + me) ; => "Bob" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 구조체(Struct)와 모음(Collection) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 구조체 +(struct dog (name breed age)) +(define my-pet + (dog "lassie" "collie" 5)) +my-pet ; => #<dog> +(dog? my-pet) ; => #t +(dog-name my-pet) ; => "lassie" + +;;; 쌍 (불변) +;; `cons'는 쌍을 만들고, `car'와 `cdr'는 첫번째와 +;; 두번째 원소를 추출한다. +(cons 1 2) ; => '(1 . 2) +(car (cons 1 2)) ; => 1 +(cdr (cons 1 2)) ; => 2 + +;;; 리스트 + +;; 리스트는 연결-리스트 데이터 구조이며, `cons' 쌍으로 만들어지며 +;; `null' (또는 '()) 로 리스트의 끝을 표시한다. +(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3) +;; `list'는 편리한 가변인자 리스트 생성자이다. +(list 1 2 3) ; => '(1 2 3) +;; 글자 그대로의 리스트 값에는 인용부호를 쓴다. +'(1 2 3) ; => '(1 2 3) + +;; 리스트의 앞에 항목을 추가하기 위하여 `cons'를 사용한다. +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; 리스트들을 붙이기 위해 `append'를 사용한다. +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; 리스트는 매우 기본적인 자료형이기 때문에, 리스트에 대해 적용되는 많은 기능들이 있다. +;; 예를 들어: +(map add1 '(1 2 3)) ; => '(2 3 4) +(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(filter even? '(1 2 3 4)) ; => '(2 4) +(count even? '(1 2 3 4)) ; => 2 +(take '(1 2 3 4) 2) ; => '(1 2) +(drop '(1 2 3 4) 2) ; => '(3 4) + +;;; 벡터 + +;; 벡터는 고정 길이의 배열이다. +#(1 2 3) ; => '#(1 2 3) + +;; `vector-append'를 사용하여 벡터들을 붙인다. +(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; 집합 + +;; 리스트로부터 집합 만들기 +(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3) + +;; 원소를 추가하려면 `set-add'를 사용한다. +;; (함수적: 확장된 집합을 반환하며, 원래의 입력을 변경하지 않는다.) +(set-add (set 1 2 3) 4) ; => (set 1 2 3 4) + +;; 원소를 삭제하려면 `set-remove' +(set-remove (set 1 2 3) 1) ; => (set 2 3) + +;; 존재 여부를 조사하려면 `set-member?' +(set-member? (set 1 2 3) 1) ; => #t +(set-member? (set 1 2 3) 4) ; => #f + +;;; 해시 + +;; 불변의 해시 테이블을 만든다. (가변 예제는 아래에) +(define m (hash 'a 1 'b 2 'c 3)) + +;; 값 꺼내기 +(hash-ref m 'a) ; => 1 + +;; 없는 값을 꺼내는 것은 예외를 발생시킨다. +; (hash-ref m 'd) => no value found + +;; 키가 없을 때 반환할 기본값을 지정할 수 있다. +(hash-ref m 'd 0) ; => 0 + +;; `hash-set'을 사용하여 불변의 해시 테이블을 확장 +;; (원래 것을 변경하지 않고 확장된 해시를 반환한다.) +(define m2 (hash-set m 'd 4)) +m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3)) + +;; 이 해시들은 불변이라는 점을 기억하시오! +m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' + +;; `hash-remove'로 키를 삭제 (이것도 함수적) +(hash-remove m 'a) ; => '#hash((b . 2) (c . 3)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 함수 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; `lambda'로 함수를 만든다. +;; 함수는 항상 마지막 식을 반환한다. +(lambda () "Hello World") ; => #<procedure> +;; 유니코드 `λ'도 사용 가능 +(λ () "Hello World") ; => same function + +;; 모든 함수를 호출할 때는 괄호를 쓴다, lambda 식도 포함하여. +((lambda () "Hello World")) ; => "Hello World" +((λ () "Hello World")) ; => "Hello World" + +;; 변수에 함수를 할당 +(define hello-world (lambda () "Hello World")) +(hello-world) ; => "Hello World" + +;; 문법적 설탕을 사용하여 함수 정의를 더 짧게할 수 있다: +(define (hello-world2) "Hello World") + +;; 위에서 ()는 함수의 인자 리스트이다. +(define hello + (lambda (name) + (string-append "Hello " name))) +(hello "Steve") ; => "Hello Steve" +;; ... 또는, 설탕 친 정의로: +(define (hello2 name) + (string-append "Hello " name)) + +;; 가변인자 함수에는 `case-lambda'를 사용한다. +(define hello3 + (case-lambda + [() "Hello World"] + [(name) (string-append "Hello " name)])) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" +;; ... 또는 선택적 인자에 기본값 지정 +(define (hello4 [name "World"]) + (string-append "Hello " name)) + +;; 함수는 추가 인자를 리스트에 포장할 수 있다. +(define (count-args . args) + (format "You passed ~a args: ~a" (length args) args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" +;; ... 설탕 안 친 `lambda' 형식으로는: +(define count-args2 + (lambda args + (format "You passed ~a args: ~a" (length args) args))) + +;; 일반 인자와 포장된 인자를 섞을 수 있다. +(define (hello-count name . args) + (format "Hello ~a, you passed ~a extra args" name (length args))) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" +;; ... 설탕 안 친 것: +(define hello-count2 + (lambda (name . args) + (format "Hello ~a, you passed ~a extra args" name (length args)))) + +;; 키워드 인자 +(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args) + (format "~a ~a, ~a extra args" g name (length args))) +(hello-k) ; => "Hello World, 0 extra args" +(hello-k 1 2 3) ; => "Hello World, 3 extra args" +(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args" +(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args" +(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6) + ; => "Hi Finn, 6 extra args" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. 동등성 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 숫자에는 `='를 사용하시오. +(= 3 3.0) ; => #t +(= 2 1) ; => #f + +;; 개체의 동등성에는 `eq?'를 사용하시오. +(eq? 3 3) ; => #t +(eq? 3 3.0) ; => #f +(eq? (list 3) (list 3)) ; => #f + +;; 모음에는 `equal?'을 사용하시오. +(equal? (list 'a 'b) (list 'a 'b)) ; => #t +(equal? (list 'a 'b) (list 'b 'a)) ; => #f + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. 흐름 제어하기 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 조건 + +(if #t ; 조사 식 + "this is true" ; 그러면 식 + "this is false") ; 아니면 식 +; => "this is true" + +;; 조건에서는 #f가 아니면 참으로 취급된다. +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'yep + +;; `cond'는 연속하여 조사하여 값을 선택한다. +(cond [(> 2 2) (error "wrong!")] + [(< 2 2) (error "wrong again!")] + [else 'ok]) ; => 'ok + +;;; 양식 맞춤 + +(define (fizzbuzz? n) + (match (list (remainder n 3) (remainder n 5)) + [(list 0 0) 'fizzbuzz] + [(list 0 _) 'fizz] + [(list _ 0) 'buzz] + [_ #f])) + +(fizzbuzz? 15) ; => 'fizzbuzz +(fizzbuzz? 37) ; => #f + +;;; 반복 + +;; 반복은 (꼬리-) 재귀로 한다. +(define (loop i) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) +(loop 5) ; => i=5, i=6, ... + +;; 이름 있는 let으로도... +(let loop ((i 0)) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) ; => i=0, i=1, ... + +;; Racket은 매우 유연한 `for' 형식을 가지고 있다: +(for ([i 10]) + (printf "i=~a\n" i)) ; => i=0, i=1, ... +(for ([i (in-range 5 10)]) + (printf "i=~a\n" i)) ; => i=5, i=6, ... + +;;; 다른 Sequence들을 순회하는 반복 +;; `for'는 여러 가지의 sequence를 순회할 수 있다: +;; 리스트, 벡터, 문자열, 집합, 해시 테이블 등... + +(for ([i (in-list '(l i s t))]) + (displayln i)) + +(for ([i (in-vector #(v e c t o r))]) + (displayln i)) + +(for ([i (in-string "string")]) + (displayln i)) + +(for ([i (in-set (set 'x 'y 'z))]) + (displayln i)) + +(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))]) + (printf "key:~a value:~a\n" k v)) + +;;; 더 복잡한 반복 + +;; 여러 sequence에 대한 병렬 순회 (가장 짧은 것 기준으로 중단) +(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x 1:y 2:z + +;; 중첩 반복 +(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z + +;; 조건 +(for ([i 1000] + #:when (> i 5) + #:unless (odd? i) + #:break (> i 10)) + (printf "i=~a\n" i)) +; => i=6, i=8, i=10 + +;;; 함축 +;; `for' 반복과 비슷하며, 결과만 수집한다. + +(for/list ([i '(1 2 3)]) + (add1 i)) ; => '(2 3 4) + +(for/list ([i '(1 2 3)] #:when (even? i)) + i) ; => '(2) + +(for/list ([i 10] [j '(x y z)]) + (list i j)) ; => '((0 x) (1 y) (2 z)) + +(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10)) + i) ; => '(6 8 10) + +(for/hash ([i '(1 2 3)]) + (values i (number->string i))) +; => '#hash((1 . "1") (2 . "2") (3 . "3")) + +;; 반복의 값을 수집하는 여러 가지 방법이 있다: +(for/sum ([i 10]) (* i i)) ; => 285 +(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 +(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t +(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t +;; 임의의 조합을 사용하려면 `for/fold'를 사용: +(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10 +;; (이것은 명령형 반복문을 대체하기도 한다.) + +;;; 예외 + +;; 예외를 잡으려면 `with-handlers' 형식을 사용 +(with-handlers ([exn:fail? (lambda (exn) 999)]) + (+ 1 "2")) ; => 999 +(with-handlers ([exn:break? (lambda (exn) "no time")]) + (sleep 3) + "phew") ; => "phew", but if you break it => "no time" + +;; 예외나 다른 값을 던지려면 `raise'를 사용 +(with-handlers ([number? ; catch numeric values raised + identity]) ; return them as plain values + (+ 1 (raise 2))) ; => 2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. 변경 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 기존 변수에 새 값을 할당하려면 `set!'을 사용한다. +(define n 5) +(set! n (add1 n)) +n ; => 6 + +;; 명시적인 가변 값을 사용하려면 box 사용 (다른 언어의 포인터나 참조와 비슷함) +(define n* (box 5)) +(set-box! n* (add1 (unbox n*))) +(unbox n*) ; => 6 + +;; 많은 Racket 자료형은 불변이다 (쌍, 리스트 등). 그러나 어떤 것들은 +;; 가변과 불변형이 둘 다 있다. (string, vector, hash table 등) + +;; `vector'나 `make-vector'로 가변 벡터를 생성한다. +(define vec (vector 2 2 3 4)) +(define wall (make-vector 100 'bottle-of-beer)) +;; 칸을 변경하려면 vector-set!을 사용한다. +(vector-set! vec 0 1) +(vector-set! wall 99 'down) +vec ; => #(1 2 3 4) + +;; 비어 있는 가변 해시 테이블을 만들고 조작한다. +(define m3 (make-hash)) +(hash-set! m3 'a 1) +(hash-set! m3 'b 2) +(hash-set! m3 'c 3) +(hash-ref m3 'a) ; => 1 +(hash-ref m3 'd 0) ; => 0 +(hash-remove! m3 'a) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. 모듈 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 모듈은 코드를 여러 파일과 재사용 가능한 라이브러리로 조직하게 한다. +;; 여기서 우리는 서브-모듈을 사용한다. 이 글이 만드는 전체 모듈("lang" 줄 부터 시작)에 포함된 모듈이다. + +(module cake racket/base ; racket/base 기반의 `cake' 모듈 정의 + + (provide print-cake) ; 모듈이 노출(export)시키는 함수 + + (define (print-cake n) + (show " ~a " n #\.) + (show " .-~a-. " n #\|) + (show " | ~a | " n #\space) + (show "---~a---" n #\-)) + + (define (show fmt n ch) ; 내부 함수 + (printf fmt (make-string n ch)) + (newline))) + +;; `require'를 사용하여 모듈에서 모든 `provide'된 이름을 사용한다. +(require 'cake) ; '는 지역 지역 서브-모듈을 위한 것이다. +(print-cake 3) +; (show "~a" 1 #\A) ; => 에러, `show'가 export되지 않았음 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. 클래스와 개체 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 클래스 fish%를 생성한다. (-%는 클래스 정의에 쓰이는 관용구) +(define fish% + (class object% + (init size) ; 초기화 인자 + (super-new) ; 상위 클래스 초기화 + ;; 필드 + (define current-size size) + ;; 공용 메서드 + (define/public (get-size) + current-size) + (define/public (grow amt) + (set! current-size (+ amt current-size))) + (define/public (eat other-fish) + (grow (send other-fish get-size))))) + +;; fish%의 인스턴스를 생성한다. +(define charlie + (new fish% [size 10])) + +;; 개체의 메서드를 호출하기 위해 `send'를 사용한다. +(send charlie get-size) ; => 10 +(send charlie grow 6) +(send charlie get-size) ; => 16 + +;; `fish%'는 보통의 "일급" 값이며, mixin을 줄 수 있다. +(define (add-color c%) + (class c% + (init color) + (super-new) + (define my-color color) + (define/public (get-color) my-color))) +(define colored-fish% (add-color fish%)) +(define charlie2 (new colored-fish% [size 10] [color 'red])) +(send charlie2 get-color) +;; 또는, 이름 없이: +(send (new (add-color fish%) [size 10] [color 'red]) get-color) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 9. 매크로 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 매크로는 언어의 문법을 확장할 수 있게 한다. + +;; while 반복문을 추가하자. +(define-syntax-rule (while condition body ...) + (let loop () + (when condition + body ... + (loop)))) + +(let ([i 0]) + (while (< i 10) + (displayln i) + (set! i (add1 i)))) + +;; 매크로는 위생적이다. 즉, 기존 변수를 침범할 수 없다. +(define-syntax-rule (swap! x y) ; -!는 변경의 관용구 + (let ([tmp x]) + (set! x y) + (set! y tmp))) + +(define tmp 2) +(define other 3) +(swap! tmp other) +(printf "tmp = ~a; other = ~a\n" tmp other) +;; `tmp` 변수는 이름 충돌을 피하기 위해 `tmp_1`로 이름이 변경된다. +;; (let ([tmp_1 tmp]) +;; (set! tmp other) +;; (set! other tmp_1)) + +;; 하지만 그것들은 단지 코드 변형일 뿐이다. 예를 들어: +(define-syntax-rule (bad-while condition body ...) + (when condition + body ... + (bad-while condition body ...))) +;; 이 매크로는 엉터리다: 무한 코드를 생성하며, +;; 이것을 사용하려고 하면 컴파일러가 무한 반복에 빠진다. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 10. 계약(Contract) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 계약은 모듈에서 노출된 값에 대해 제약을 부여한다. + +(module bank-account racket + (provide (contract-out + [deposit (-> positive? any)] ; 값은 양수여야 함 + [balance (-> positive?)])) + + (define amount 0) + (define (deposit a) (set! amount (+ amount a))) + (define (balance) amount) + ) + +(require 'bank-account) +(deposit 5) + +(balance) ; => 5 + +;; 양수가 아닌 값을 예치하려고 하는 고객은 비난받는다. +;; (deposit -5) ; => deposit: contract violation +;; expected: positive? +;; given: -5 +;; more details.... + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 11. 입력과 출력 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Racket은 이 "port"라는 개념이 있다. 이것은 다른 언어의 +;; 파일 서술자 (file descriptor)와 매우 비슷하다. + +;; "/tmp/tmp.txt"를 열고 "Hello World"를 기록한다. +;; 그 파일이 이미 있다면 에러를 발생시킨다. +(define out-port (open-output-file "/tmp/tmp.txt")) +(displayln "Hello World" out-port) +(close-output-port out-port) + +;; "/tmp/tmp.txt"에 붙이기 +(define out-port (open-output-file "/tmp/tmp.txt" + #:exists 'append)) +(displayln "Hola mundo" out-port) +(close-output-port out-port) + +;; 파일에서 다시 읽기 +(define in-port (open-input-file "/tmp/tmp.txt")) +(displayln (read-line in-port)) +; => "Hello World" +(displayln (read-line in-port)) +; => "Hola mundo" +(close-input-port in-port) + +;; 다르게, call-with-output-file을 사용하면, 명시적으로 파일을 닫지 않아도 된다. +(call-with-output-file "/tmp/tmp.txt" + #:exists 'update ; 내용을 다시 쓴다. + (λ (out-port) + (displayln "World Hello!" out-port))) + +;; call-with-input-file은 입력에 대해 같은 방식으로 작동한다. +(call-with-input-file "/tmp/tmp.txt" + (λ (in-port) + (displayln (read-line in-port)))) +``` + +## 더 읽을거리 + +더 배우고 싶으면, [Getting Started with Racket](http://docs.racket-lang.org/getting-started/)도 보시오. diff --git a/livescript.html.markdown b/livescript.html.markdown index 8e11439b..9235f5ce 100644 --- a/livescript.html.markdown +++ b/livescript.html.markdown @@ -23,7 +23,7 @@ Feedback is always welcome, so feel free to reach me over at ```coffeescript -# Just like its CoffeeScript cousin, LiveScript uses hash symbols for +# Just like its CoffeeScript cousin, LiveScript uses number symbols for # single-line comments. /* @@ -135,11 +135,19 @@ funRE = // 3 % 2 # => 1 -# Comparisons are mostly the same too, except that `==` and `===` are -# inverted. +# Comparisons are mostly the same too, except that `==` is the same as +# JS's `===`, where JS's `==` in LiveScript is `~=`, and `===` enables +# object and array comparisons, and also stricter comparisons: 2 == 2 # => true 2 == "2" # => false -2 === "2" # => true +2 ~= "2" # => true +2 === "2" # => false + +[1,2,3] == [1,2,3] # => false +[1,2,3] === [1,2,3] # => true + ++0 == -0 # => true ++0 === -0 # => false # Other relational operators include <, <=, > and >= @@ -158,7 +166,7 @@ not false # => true ######################################################################## ## 3. Functions -######################################################################## +######################################################################## # Since LiveScript is functional, you'd expect functions to get a nice # treatment. In LiveScript it's even more apparent that functions are @@ -211,8 +219,8 @@ identity 1 # => 1 # Operators are not functions in LiveScript, but you can easily turn # them into one! Enter the operator sectioning: -divide-by-2 = (/ 2) -[2, 4, 8, 16].map(divide-by-2) .reduce (+) +divide-by-two = (/ 2) +[2, 4, 8, 16].map(divide-by-two) .reduce (+) # Not only of function application lives LiveScript, as in any good @@ -221,7 +229,7 @@ double-minus-one = (- 1) . (* 2) # Other than the usual `f . g` mathematical formulae, you get the `>>` # and `<<` operators, that describe how the flow of values through the -# functions. +# functions. double-minus-one = (* 2) >> (- 1) double-minus-one = (- 1) << (* 2) @@ -240,8 +248,8 @@ reduce = (f, xs, initial) --> xs.reduce f, initial # The underscore is also used in regular partial application, which you # can use for any function: div = (left, right) -> left / right -div-by-2 = div _, 2 -div-by-2 4 # => 2 +div-by-two = div _, 2 +div-by-two 4 # => 2 # Last, but not least, LiveScript has back-calls, which might help @@ -336,7 +344,7 @@ kitten.hug! # => "*Mei (a cat) is hugged*" ## Further reading There's just so much more to LiveScript, but this should be enough to -get you started writing little functional things in it. The +get you started writing little functional things in it. The [official website](http://livescript.net/) has a lot of information on the language, and a nice online compiler for you to try stuff out! diff --git a/lua.html.markdown b/lua.html.markdown index 7325a1cf..0809215f 100644 --- a/lua.html.markdown +++ b/lua.html.markdown @@ -1,5 +1,5 @@ --- -language: lua +language: Lua contributors: - ["Tyler Neylon", "http://tylerneylon.com/"] filename: learnlua.lua @@ -12,15 +12,13 @@ filename: learnlua.lua Adding two ['s and ]'s makes it a multi-line comment. --]] - ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 1. Variables and flow control. ----------------------------------------------------- +-------------------------------------------------------------------------------- num = 42 -- All numbers are doubles. --- Don't freak out, 64-bit doubles have 52 bits for --- storing exact int values; machine precision is --- not a problem for ints that need < 52 bits. +-- Don't freak out, 64-bit doubles have 52 bits for storing exact int +-- values; machine precision is not a problem for ints that need < 52 bits. s = 'walternate' -- Immutable strings like Python. t = "double-quotes are also fine" @@ -60,8 +58,8 @@ aBoolValue = false -- Only nil and false are falsy; 0 and '' are true! if not aBoolValue then print('twas false') end --- 'or' and 'and' are short-circuited. --- This is similar to the a?b:c operator in C/js: +-- 'or' and 'and' are short-circuited. This is similar to the a?b:c operator +-- in C/js: ans = aBoolValue and 'yes' or 'no' --> 'no' karlSum = 0 @@ -81,10 +79,9 @@ repeat num = num - 1 until num == 0 - ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 2. Functions. ----------------------------------------------------- +-------------------------------------------------------------------------------- function fib(n) if n < 2 then return n end @@ -93,8 +90,8 @@ end -- Closures and anonymous functions are ok: function adder(x) - -- The returned function is created when adder is - -- called, and remembers the value of x: + -- The returned function is created when adder is called, and remembers the + -- value of x: return function (y) return x + y end end a1 = adder(9) @@ -102,10 +99,9 @@ a2 = adder(36) print(a1(16)) --> 25 print(a2(64)) --> 100 --- Returns, func calls, and assignments all work --- with lists that may be mismatched in length. --- Unmatched receivers are nil; --- unmatched senders are discarded. +-- Returns, func calls, and assignments all work with lists that may be +-- mismatched in length. Unmatched receivers are nil; unmatched senders are +-- discarded. x, y, z = 1, 2, 3, 4 -- Now x = 1, y = 2, z = 3, and 4 is thrown away. @@ -118,13 +114,15 @@ end x, y = bar('zaphod') --> prints "zaphod nil nil" -- Now x = 4, y = 8, values 15..42 are discarded. --- Functions are first-class, may be local/global. --- These are the same: +-- Functions are first-class, may be local/global. These are the same: function f(x) return x * x end f = function (x) return x * x end -- And so are these: local function g(x) return math.sin(x) end +local g = function(x) return math.sin(x) end +-- Equivalent to local function g(x)..., except referring to g in the function +-- body won't work as expected. local g; g = function (x) return math.sin(x) end -- the 'local g' decl makes g-self-references ok. @@ -133,15 +131,16 @@ local g; g = function (x) return math.sin(x) end -- Calls with one string param don't need parens: print 'hello' -- Works fine. +-- Calls with one table param don't need parens either (more on tables below): +print {} -- Works fine too. ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 3. Tables. ----------------------------------------------------- +-------------------------------------------------------------------------------- --- Tables = Lua's only compound data structure; --- they are associative arrays. --- Similar to php arrays or js objects, they are --- hash-lookup dicts that can also be used as lists. +-- Tables = Lua's only compound data structure; they are associative arrays. +-- Similar to php arrays or js objects, they are hash-lookup dicts that can +-- also be used as lists. -- Using tables as dictionaries / maps: @@ -157,14 +156,13 @@ t.key2 = nil -- Removes key2 from the table. u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} print(u[6.28]) -- prints "tau" --- Key matching is basically by value for numbers --- and strings, but by identity for tables. +-- Key matching is basically by value for numbers and strings, but by identity +-- for tables. a = u['@!#'] -- Now a = 'qbert'. b = u[{}] -- We might expect 1729, but it's nil: --- b = nil since the lookup fails. It fails --- because the key we used is not the same object --- as the one used to store the original value. So --- strings & numbers are more portable keys. +-- b = nil since the lookup fails. It fails because the key we used is not the +-- same object as the one used to store the original value. So strings & +-- numbers are more portable keys. -- A one-table-param function call needs no parens: function h(x) print(x.key1) end @@ -184,16 +182,15 @@ v = {'value1', 'value2', 1.21, 'gigawatts'} for i = 1, #v do -- #v is the size of v for lists. print(v[i]) -- Indices start at 1 !! SO CRAZY! end --- A 'list' is not a real type. v is just a table --- with consecutive integer keys, treated as a list. +-- A 'list' is not a real type. v is just a table with consecutive integer +-- keys, treated as a list. ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 3.1 Metatables and metamethods. ----------------------------------------------------- +-------------------------------------------------------------------------------- --- A table can have a metatable that gives the table --- operator-overloadish behavior. Later we'll see --- how metatables support js-prototypey behavior. +-- A table can have a metatable that gives the table operator-overloadish +-- behavior. Later we'll see how metatables support js-prototypey behavior. f1 = {a = 1, b = 2} -- Represents the fraction a/b. f2 = {a = 2, b = 3} @@ -203,7 +200,7 @@ f2 = {a = 2, b = 3} metafraction = {} function metafraction.__add(f1, f2) - sum = {} + local sum = {} sum.b = f1.b * f2.b sum.a = f1.a * f2.b + f2.a * f1.b return sum @@ -214,10 +211,9 @@ setmetatable(f2, metafraction) s = f1 + f2 -- call __add(f1, f2) on f1's metatable --- f1, f2 have no key for their metatable, unlike --- prototypes in js, so you must retrieve it as in --- getmetatable(f1). The metatable is a normal table --- with keys that Lua knows about, like __add. +-- f1, f2 have no key for their metatable, unlike prototypes in js, so you must +-- retrieve it as in getmetatable(f1). The metatable is a normal table with +-- keys that Lua knows about, like __add. -- But the next line fails since s has no metatable: -- t = s + s @@ -229,11 +225,12 @@ myFavs = {food = 'pizza'} setmetatable(myFavs, {__index = defaultFavs}) eatenBy = myFavs.animal -- works! thanks, metatable --- Direct table lookups that fail will retry using --- the metatable's __index value, and this recurses. +-------------------------------------------------------------------------------- +-- Direct table lookups that fail will retry using the metatable's __index +-- value, and this recurses. --- An __index value can also be a function(tbl, key) --- for more customized lookups. +-- An __index value can also be a function(tbl, key) for more customized +-- lookups. -- Values of __index,add, .. are called metamethods. -- Full list. Here a is a table with the metamethod. @@ -254,19 +251,19 @@ eatenBy = myFavs.animal -- works! thanks, metatable -- __newindex(a, b, c) for a.b = c -- __call(a, ...) for a(...) ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 3.2 Class-like tables and inheritance. ----------------------------------------------------- +-------------------------------------------------------------------------------- --- Classes aren't built in; there are different ways --- to make them using tables and metatables. +-- Classes aren't built in; there are different ways to make them using +-- tables and metatables. -- Explanation for this example is below it. Dog = {} -- 1. function Dog:new() -- 2. - newObj = {sound = 'woof'} -- 3. + local newObj = {sound = 'woof'} -- 3. self.__index = self -- 4. return setmetatable(newObj, self) -- 5. end @@ -279,62 +276,59 @@ mrDog = Dog:new() -- 7. mrDog:makeSound() -- 'I say woof' -- 8. -- 1. Dog acts like a class; it's really a table. --- 2. function tablename:fn(...) is the same as --- function tablename.fn(self, ...) --- The : just adds a first arg called self. --- Read 7 & 8 below for how self gets its value. +-- 2. "function tablename:fn(...)" is the same as +-- "function tablename.fn(self, ...)", The : just adds a first arg called +-- self. Read 7 & 8 below for how self gets its value. -- 3. newObj will be an instance of class Dog. --- 4. self = the class being instantiated. Often --- self = Dog, but inheritance can change it. --- newObj gets self's functions when we set both --- newObj's metatable and self's __index to self. +-- 4. "self" is the class being instantiated. Often self = Dog, but inheritance +-- can change it. newObj gets self's functions when we set both newObj's +-- metatable and self's __index to self. -- 5. Reminder: setmetatable returns its first arg. --- 6. The : works as in 2, but this time we expect --- self to be an instance instead of a class. +-- 6. The : works as in 2, but this time we expect self to be an instance +-- instead of a class. -- 7. Same as Dog.new(Dog), so self = Dog in new(). -- 8. Same as mrDog.makeSound(mrDog); self = mrDog. ----------------------------------------------------- +-------------------------------------------------------------------------------- -- Inheritance example: LoudDog = Dog:new() -- 1. function LoudDog:makeSound() - s = self.sound .. ' ' -- 2. + local s = self.sound .. ' ' -- 2. print(s .. s .. s) end seymour = LoudDog:new() -- 3. seymour:makeSound() -- 'woof woof woof' -- 4. +-------------------------------------------------------------------------------- -- 1. LoudDog gets Dog's methods and variables. -- 2. self has a 'sound' key from new(), see 3. --- 3. Same as LoudDog.new(LoudDog), and converted to --- Dog.new(LoudDog) as LoudDog has no 'new' key, --- but does have __index = Dog on its metatable. --- Result: seymour's metatable is LoudDog, and --- LoudDog.__index = LoudDog. So seymour.key will --- = seymour.key, LoudDog.key, Dog.key, whichever +-- 3. Same as "LoudDog.new(LoudDog)", and converted to "Dog.new(LoudDog)" as +-- LoudDog has no 'new' key, but does have "__index = Dog" on its metatable. +-- Result: seymour's metatable is LoudDog, and "LoudDog.__index = Dog". So +-- seymour.key will equal seymour.key, LoudDog.key, Dog.key, whichever -- table is the first with the given key. --- 4. The 'makeSound' key is found in LoudDog; this --- is the same as LoudDog.makeSound(seymour). +-- 4. The 'makeSound' key is found in LoudDog; this is the same as +-- "LoudDog.makeSound(seymour)". -- If needed, a subclass's new() is like the base's: function LoudDog:new() - newObj = {} + local newObj = {} -- set up newObj self.__index = self return setmetatable(newObj, self) end ----------------------------------------------------- +-------------------------------------------------------------------------------- -- 4. Modules. ----------------------------------------------------- +-------------------------------------------------------------------------------- ---[[ I'm commenting out this section so the rest of --- this script remains runnable. +--[[ I'm commenting out this section so the rest of this script remains +-- runnable. ``` ```lua @@ -360,8 +354,8 @@ local mod = require('mod') -- Run the file mod.lua. local mod = (function () <contents of mod.lua> end)() --- It's like mod.lua is a function body, so that --- locals inside mod.lua are invisible outside it. +-- It's like mod.lua is a function body, so that locals inside mod.lua are +-- invisible outside it. -- This works because mod here = M in mod.lua: mod.sayHello() -- Says hello to Hrunkner. @@ -369,8 +363,8 @@ mod.sayHello() -- Says hello to Hrunkner. -- This is wrong; sayMyName only exists in mod.lua: mod.sayMyName() -- error --- require's return values are cached so a file is --- run at most once, even when require'd many times. +-- require's return values are cached so a file is run at most once, even when +-- require'd many times. -- Suppose mod2.lua contains "print('Hi!')". local a = require('mod2') -- Prints Hi! diff --git a/make.html.markdown b/make.html.markdown new file mode 100644 index 00000000..563139d1 --- /dev/null +++ b/make.html.markdown @@ -0,0 +1,243 @@ +---
+language: make
+contributors:
+ - ["Robert Steed", "https://github.com/robochat"]
+filename: Makefile
+---
+
+A Makefile defines a graph of rules for creating a target (or targets).
+Its purpose is to do the minimum amount of work needed to update a
+target to the most recent version of the source. Famously written over a
+weekend by Stuart Feldman in 1976, it is still widely used (particularly
+on Unix) despite many competitors and criticisms.
+
+There are many varieties of make in existance, this article assumes that
+we are using GNU make which is the standard on Linux.
+
+```make
+
+# Comments can be written like this.
+
+# Files should be named Makefile and then be can run as `make <target>`.
+# Otherwise we use `make -f "filename" <target>`.
+
+# Warning - only use TABS to indent in Makefiles, never spaces!
+
+#-----------------------------------------------------------------------
+# Basics
+#-----------------------------------------------------------------------
+
+# A rule - this rule will only run if file0.txt doesn't exist.
+file0.txt:
+ echo "foo" > file0.txt
+ # Even comments in these 'recipe' sections get passed to the shell.
+ # Try `make file0.txt` or simply `make` - first rule is the default.
+
+
+# This rule will only run if file0.txt is newer than file1.txt.
+file1.txt: file0.txt
+ cat file0.txt > file1.txt
+ # use the same quoting rules as in the shell.
+ @cat file0.txt >> file1.txt
+ # @ stops the command from being echoed to stdout.
+ -@echo 'hello'
+ # - means that make will keep going in the case of an error.
+ # Try `make file1.txt` on the commandline.
+
+# A rule can have multiple targets and multiple prerequisites
+file2.txt file3.txt: file0.txt file1.txt
+ touch file2.txt
+ touch file3.txt
+
+# Make will complain about multiple recipes for the same rule. Empty
+# recipes don't count though and can be used to add new dependencies.
+
+#-----------------------------------------------------------------------
+# Phony Targets
+#-----------------------------------------------------------------------
+
+# A phony target. Any target that isn't a file.
+# It will never be up to date so make will always try to run it.
+all: maker process
+
+# We can declare things out of order.
+maker:
+ touch ex0.txt ex1.txt
+
+# Can avoid phony rules breaking when a real file has the same name by
+.PHONY: all maker process
+# This is a special target. There are several others.
+
+# A rule with a dependency on a phony target will always run
+ex0.txt ex1.txt: maker
+
+# Common phony targets are: all make clean install ...
+
+#-----------------------------------------------------------------------
+# Automatic Variables & Wildcards
+#-----------------------------------------------------------------------
+
+process: file*.txt #using a wildcard to match filenames
+ @echo $^ # $^ is a variable containing the list of prerequisites
+ @echo $@ # prints the target name
+ #(for multiple target rules, $@ is whichever caused the rule to run)
+ @echo $< # the first prerequisite listed
+ @echo $? # only the dependencies that are out of date
+ @echo $+ # all dependencies including duplicates (unlike normal)
+ #@echo $| # all of the 'order only' prerequisites
+
+# Even if we split up the rule dependency definitions, $^ will find them
+process: ex1.txt file0.txt
+# ex1.txt will be found but file0.txt will be deduplicated.
+
+#-----------------------------------------------------------------------
+# Patterns
+#-----------------------------------------------------------------------
+
+# Can teach make how to convert certain files into other files.
+
+%.png: %.svg
+ inkscape --export-png $^
+
+# Pattern rules will only do anything if make decides to create the \
+target.
+
+# Directory paths are normally ignored when matching pattern rules. But
+# make will try to use the most appropriate rule available.
+small/%.png: %.svg
+ inkscape --export-png --export-dpi 30 $^
+
+# make will use the last version for a pattern rule that it finds.
+%.png: %.svg
+ @echo this rule is chosen
+
+# However make will use the first pattern rule that can make the target
+%.png: %.ps
+ @echo this rule is not chosen if *.svg and *.ps are both present
+
+# make already has some pattern rules built-in. For instance, it knows
+# how to turn *.c files into *.o files.
+
+# Older makefiles might use suffix rules instead of pattern rules
+.png.ps:
+ @echo this rule is similar to a pattern rule.
+
+# Tell make about the suffix rule
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variables
+#-----------------------------------------------------------------------
+# aka. macros
+
+# Variables are basically all string types
+
+name = Ted
+name2="Sarah"
+
+echo:
+ @echo $(name)
+ @echo ${name2}
+ @echo $name # This won't work, treated as $(n)ame.
+ @echo $(name3) # Unknown variables are treated as empty strings.
+
+# There are 4 places to set variables.
+# In order of priority from highest to lowest:
+# 1: commandline arguments
+# 2: Makefile
+# 3: shell enviroment variables - make imports these automatically.
+# 4: make has some predefined variables
+
+name4 ?= Jean
+# Only set the variable if enviroment variable is not already defined.
+
+override name5 = David
+# Stops commandline arguments from changing this variable.
+
+name4 +=grey
+# Append values to variable (includes a space).
+
+# Pattern-specific variable values (GNU extension).
+echo: name2 = Sara # True within the matching rule
+ # and also within its remade recursive dependencies
+ # (except it can break when your graph gets too complicated!)
+
+# Some variables defined automatically by make.
+echo_inbuilt:
+ echo $(CC)
+ echo ${CXX)}
+ echo $(FC)
+ echo ${CFLAGS)}
+ echo $(CPPFLAGS)
+ echo ${CXXFLAGS}
+ echo $(LDFLAGS)
+ echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variables 2
+#-----------------------------------------------------------------------
+
+# The first type of variables are evaluated each time they are used.
+# This can be expensive, so a second type of variable exists which is
+# only evaluated once. (This is a GNU make extension)
+
+var := hello
+var2 ::= $(var) hello
+#:= and ::= are equivalent.
+
+# These variables are evaluated procedurely (in the order that they
+# appear), thus breaking with the rest of the language !
+
+# This doesn't work
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------
+
+# make has lots of functions available.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# Format is $(func arg0,arg1,arg2...)
+
+# Some examples
+ls: * src/*
+ @echo $(filter %.txt, $^)
+ @echo $(notdir $^)
+ @echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directives
+#-----------------------------------------------------------------------
+
+# Include other makefiles, useful for platform specific code
+include foo.mk
+
+sport = tennis
+# Conditional compilation
+report:
+ifeq ($(sport),tennis)
+ @echo 'game, set, match'
+else
+ @echo "They think it's all over; it is now"
+endif
+
+# There are also ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+
+### More Resources
+
++ [gnu make documentation](https://www.gnu.org/software/make/manual/)
++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)
++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
+
diff --git a/markdown.html.markdown b/markdown.html.markdown new file mode 100644 index 00000000..2333110f --- /dev/null +++ b/markdown.html.markdown @@ -0,0 +1,260 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +filename: markdown.md +--- + +Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well). + +Give me as much feedback as you want! / Feel free to fork and pull request! + + +```markdown +<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that +means we can use HTML elements in Markdown, such as the comment element, and +they won't be affected by a markdown parser. However, if you create an HTML +element in your markdown file, you cannot use markdown syntax within that +element's contents. --> + +<!-- Markdown also varies in implementation from one parser to a next. This +guide will attempt to clarify when features are universal or when they are +specific to a certain parser. --> + +<!-- Headers --> +<!-- You can create HTML elements <h1> through <h6> easily by prepending the +text you want to be in that element by a number of hashes (#) --> +# This is an <h1> +## This is an <h2> +### This is an <h3> +#### This is an <h4> +##### This is an <h5> +###### This is an <h6> + +<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 --> +This is an h1 +============= + +This is an h2 +------------- + +<!-- Simple text styles --> +<!-- Text can be easily styled as italic or bold using markdown --> + +*This text is in italics.* +_And so is this text._ + +**This text is in bold.** +__And so is this text.__ + +***This text is in both.*** +**_As is this!_** +*__And this!__* + +<!-- In Github Flavored Markdown, which is used to render markdown files on +Github, we also have strikethrough: --> + +~~This text is rendered with strikethrough.~~ + +<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or +multiple blank lines. --> + +This is a paragraph. I'm typing in a paragraph isn't this fun? + +Now I'm in paragraph 2. +I'm still in paragraph 2 too! + + +I'm in paragraph three! + +<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph +with two or more spaces and then begin a new paragraph. --> + +I end with two spaces (highlight me to see them). + +There's a <br /> above me! + +<!-- Block quotes are easy and done with the > character. --> + +> This is a block quote. You can either +> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own. +> It doesn't make a difference so long as they start with a `>`. + +> You can also use more than one level +>> of indentation? +> How neat is that? + +<!-- Lists --> +<!-- Unordered lists can be made using asterisks, pluses, or hyphens --> + +* Item +* Item +* Another item + +or + ++ Item ++ Item ++ One more item + +or + +- Item +- Item +- One last item + +<!-- Ordered lists are done with a number followed by a period --> + +1. Item one +2. Item two +3. Item three + +<!-- You don't even have to label the items correctly and markdown will still +render the numbers in order, but this may not be a good idea --> + +1. Item one +1. Item two +1. Item three +<!-- (This renders the same as the above example) --> + +<!-- You can also use sublists --> + +1. Item one +2. Item two +3. Item three + * Sub-item + * Sub-item +4. Item four + +<!-- There are even task lists. This creates HTML checkboxes. --> + +Boxes below without the 'x' are unchecked HTML checkboxes. +- [ ] First task to complete. +- [ ] Second task that needs done +This checkbox below will be a checked HTML checkbox. +- [x] This task has been completed + +<!-- Code blocks --> +<!-- You can indicate a code block (which uses the <code> element) by indenting +a line with four spaces or a tab --> + + This is code + So is this + +<!-- You can also re-tab (or add an additional four spaces) for indentation +inside your code --> + + my_array.each do |item| + puts item + end + +<!-- Inline code can be created using the backtick character ` --> + +John didn't even know what the `go_to()` function did! + +<!-- In Github Flavored Markdown, you can use a special syntax for code --> + +\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- here too, no backslashes, just ``` --> + +<!-- The above text doesn't require indenting, plus Github will use syntax +highlighting of the language you specify after the ``` --> + +<!-- Horizontal rule (<hr />) --> +<!-- Horizontal rules are easily added with three or more asterisks or hyphens, +with or without spaces. --> + +*** +--- +- - - +**************** + +<!-- Links --> +<!-- One of the best things about markdown is how easy it is to make links. Put +the text to display in hard brackets [] followed by the url in parentheses () --> + +[Click me!](http://test.com/) + +<!-- You can also add a link title using quotes inside the parentheses --> + +[Click me!](http://test.com/ "Link to Test.com") + +<!-- Relative paths work too. --> + +[Go to music](/music/). + +<!-- Markdown also supports reference style links --> + +[Click this link][link1] for more info about it! +[Also check out this link][foobar] if you want to. + +[link1]: http://test.com/ "Cool!" +[foobar]: http://foobar.biz/ "Alright!" + +<!-- The title can also be in single quotes or in parentheses, or omitted +entirely. The references can be anywhere in your document and the reference IDs +can be anything so long as they are unique. --> + +<!-- There is also "implicit naming" which lets you use the link text as the id --> + +[This][] is a link. + +[this]: http://thisisalink.com/ + +<!-- But it's not that commonly used. --> + +<!-- Images --> +<!-- Images are done the same way as links but with an exclamation point in front! --> + + + +<!-- And reference style works as expected --> + +![This is the alt-attribute.][myimage] + +[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here" + +<!-- Miscellany --> +<!-- Auto-links --> + +<http://testwebsite.com/> is equivalent to +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Auto-links for emails --> + +<foo@bar.com> + +<!-- Escaping characters --> + +I want to type *this text surrounded by asterisks* but I don't want it to be +in italics, so I do this: \*this text surrounded by asterisks\*. + +<!-- Keyboard keys --> +<!-- In Github Flavored Markdown, you can use a <kbd> tag to represent keyboard keys --> + +Your computer crashed? Try sending a +<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd> + +<!-- Tables --> +<!-- Tables are only available in Github Flavored Markdown and are slightly +cumbersome, but if you really want it: --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| Left-aligned | Centered | Right-aligned | +| blah | blah | blah | + +<!-- or, for the same results --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ugh this is so ugly | make it | stop + +<!-- The end! --> + +``` + +For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). diff --git a/matlab.html.markdown b/matlab.html.markdown new file mode 100644 index 00000000..02fe5962 --- /dev/null +++ b/matlab.html.markdown @@ -0,0 +1,473 @@ +--- +language: Matlab +contributors: + - ["mendozao", "http://github.com/mendozao"] + - ["jamesscottbrown", "http://jamesscottbrown.com"] + +--- + +MATLAB stands for MATrix LABoratory. It is a powerful numerical computing language commonly used in engineering and mathematics. + +If you have any feedback please feel free to reach me at +[@the_ozzinator](https://twitter.com/the_ozzinator), or +[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com). + +```matlab +% Comments start with a percent sign. + +%{ +Multi line comments look +something +like +this +%} + +% commands can span multiple lines, using '...': + a = 1 + 2 + ... + + 4 + +% commands can be passed to the operating system +!ping google.com + +who % Displays all variables in memory +whos % Displays all variables in memory, with their types +clear % Erases all your variables from memory +clear('A') % Erases a particular variable +openvar('A') % Open variable in variable editor + +clc % Erases the writing on your Command Window +diary % Toggle writing Command Window text to file +ctrl-c % Abort current computation + +edit('myfunction.m') % Open function/script in editor +type('myfunction.m') % Print the source of function/script to Command Window + +profile on % turns on the code profiler +profile off % turns off the code profiler +profile viewer % Open profiler + +help command % Displays documentation for command in Command Window +doc command % Displays documentation for command in Help Window +lookfor command % Searches for command in the first commented line of all functions +lookfor command -all % searches for command in all functions + + +% Output formatting +format short % 4 decimals in a floating number +format long % 15 decimals +format bank % only two digits after decimal point - for financial calculations +fprintf('text') % print "text" to the screen +disp('text') % print "text" to the screen + +% Variables & Expressions +myVariable = 4 % Notice Workspace pane shows newly created variable +myVariable = 4; % Semi colon suppresses output to the Command Window +4 + 6 % ans = 10 +8 * myVariable % ans = 32 +2 ^ 3 % ans = 8 +a = 2; b = 3; +c = exp(a)*sin(pi/2) % c = 7.3891 + +% Calling functions can be done in either of two ways: +% Standard function syntax: +load('myFile.mat', 'y') % arguments within parantheses, spererated by commas +% Command syntax: +load myFile.mat y % no parentheses, and spaces instead of commas +% Note the lack of quote marks in command form: inputs are always passed as +% literal text - cannot pass variable values. Also, can't receive output: +[V,D] = eig(A); % this has no equivalent in command form +[~,D] = eig(A); % if you only want D and not V + + + +% Logicals +1 > 5 % ans = 0 +10 >= 10 % ans = 1 +3 ~= 4 % Not equal to -> ans = 1 +3 == 3 % equal to -> ans = 1 +3 > 1 && 4 > 1 % AND -> ans = 1 +3 > 1 || 4 > 1 % OR -> ans = 1 +~1 % NOT -> ans = 0 + +% Logicals can be applied to matrices: +A > 5 +% for each element, if condition is true, that element is 1 in returned matrix +A( A > 5 ) +% returns a vector containing the elements in A for which condition is true + +% Strings +a = 'MyString' +length(a) % ans = 8 +a(2) % ans = y +[a,a] % ans = MyStringMyString + + +% Cells +a = {'one', 'two', 'three'} +a(1) % ans = 'one' - returns a cell +char(a(1)) % ans = one - returns a string + +% Structures +A.b = {'one','two'}; +A.c = [1 2]; +A.d.e = false; + +% Vectors +x = [4 32 53 7 1] +x(2) % ans = 32, indices in Matlab start 1, not 0 +x(2:3) % ans = 32 53 +x(2:end) % ans = 32 53 7 1 + +x = [4; 32; 53; 7; 1] % Column vector + +x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10 + +% Matrices +A = [1 2 3; 4 5 6; 7 8 9] +% Rows are separated by a semicolon; elements are separated with space or comma +% A = + +% 1 2 3 +% 4 5 6 +% 7 8 9 + +A(2,3) % ans = 6, A(row, column) +A(6) % ans = 8 +% (implicitly concatenates columns into vector, then indexes into that) + + +A(2,3) = 42 % Update row 2 col 3 with 42 +% A = + +% 1 2 3 +% 4 5 42 +% 7 8 9 + +A(2:3,2:3) % Creates a new matrix from the old one +%ans = + +% 5 42 +% 8 9 + +A(:,1) % All rows in column 1 +%ans = + +% 1 +% 4 +% 7 + +A(1,:) % All columns in row 1 +%ans = + +% 1 2 3 + +[A ; A] % Concatenation of matrices (vertically) +%ans = + +% 1 2 3 +% 4 5 42 +% 7 8 9 +% 1 2 3 +% 4 5 42 +% 7 8 9 + +% this is the same as +vertcat(A,A); + + +[A , A] % Concatenation of matrices (horizontally) + +%ans = + +% 1 2 3 1 2 3 +% 4 5 42 4 5 42 +% 7 8 9 7 8 9 + +% this is the same as +horzcat(A,A); + + +A(:, [3 1 2]) % Rearrange the columns of original matrix +%ans = + +% 3 1 2 +% 42 4 5 +% 9 7 8 + +size(A) % ans = 3 3 + +A(1, :) =[] % Delete the first row of the matrix +A(:, 1) =[] % Delete the first column of the matrix + +transpose(A) % Transpose the matrix, which is the same as: +A one +ctranspose(A) % Hermitian transpose the matrix +% (the transpose, followed by taking complex conjugate of each element) + + + + +% Element by Element Arithmetic vs. Matrix Arithmetic +% On their own, the arithmetic operators act on whole matrices. When preceded +% by a period, they act on each element instead. For example: +A * B % Matrix multiplication +A .* B % Multiple each element in A by its corresponding element in B + +% There are several pairs of functions, where one acts on each element, and +% the other (whose name ends in m) acts on the whole matrix. +exp(A) % exponentiate each element +expm(A) % calculate the matrix exponential +sqrt(A) % take the square root of each element +sqrtm(A) % find the matrix whose square is A + + +% Plotting +x = 0:.10:2*pi; % Creates a vector that starts at 0 and ends at 2*pi with increments of .1 +y = sin(x); +plot(x,y) +xlabel('x axis') +ylabel('y axis') +title('Plot of y = sin(x)') +axis([0 2*pi -1 1]) % x range from 0 to 2*pi, y range from -1 to 1 + +plot(x,y1,'-',x,y2,'--',x,y3,':') % For multiple functions on one plot +legend('Line 1 label', 'Line 2 label') % Label curves with a legend + +% Alternative method to plot multiple functions in one plot. +% while 'hold' is on, commands add to existing graph rather than replacing it +plot(x, y) +hold on +plot(x, z) +hold off + +loglog(x, y) % A log-log plot +semilogx(x, y) % A plot with logarithmic x-axis +semilogy(x, y) % A plot with logarithmic y-axis + +fplot (@(x) x^2, [2,5]) % plot the function x^2 from x=2 to x=5 + +grid on % Show grid; turn off with 'grid off' +axis square % Makes the current axes region square +axis equal % Set aspect ratio so data units are the same in every direction + +scatter(x, y); % Scatter-plot +hist(x); % Histogram + +z = sin(x); +plot3(x,y,z); % 3D line plot + +pcolor(A) % Heat-map of matrix: plot as grid of rectangles, coloured by value +contour(A) % Contour plot of matrix +mesh(A) % Plot as a mesh surface + +h = figure % Create new figure object, with handle f +figure(h) % Makes the figure corresponding to handle h the current figure +close(h) % close figure with handle h +close all % close all open figure windows +close % close current figure window + +shg % bring an existing graphics window forward, or create new one if needed +clf clear % clear current figure window, and reset most figure properties + +% Properties can be set and changed through a figure handle. +% You can save a handle to a figure when you create it. +% The function gcf returns a handle to the current figure +h = plot(x, y); % you can save a handle to a figure when you create it +set(h, 'Color', 'r') +% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black +set(h, 'LineStyle', '--') + % '--' is solid line, '---' dashed, ':' dotted, '-.' dash-dot, 'none' is no line +get(h, 'LineStyle') + + +% The function gca returns a handle to the axes for the current figure +set(gca, 'XDir', 'reverse'); % reverse the direction of the x-axis + +% To create a figure that contains several axes in tiled positions, use subplot +subplot(2,3,1); % select the first position in a 2-by-3 grid of subplots +plot(x1); title('First Plot') % plot something in this position +subplot(2,3,2); % select second position in the grid +plot(x2); title('Second Plot') % plot something there + + +% To use functions or scripts, they must be on your path or current directory +path % display current path +addpath /path/to/dir % add to path +rmpath /path/to/dir % remove from path +cd /path/to/move/into % change directory + + +% Variables can be saved to .mat files +save('myFileName.mat') % Save the variables in your Workspace +load('myFileName.mat') % Load saved variables into Workspace + +% M-file Scripts +% A script file is an external file that contains a sequence of statements. +% They let you avoid repeatedly typing the same code in the Command Window +% Have .m extensions + +% M-file Functions +% Like scripts, and have the same .m extension +% But can accept input arguments and return an output +% Also, they have their own workspace (ie. different variable scope). +% Function name should match file name (so save this example as double_input.m). +% 'help double_input.m' returns the comments under line beginning function +function output = double_input(x) + %double_input(x) returns twice the value of x + output = 2*x; +end +double_input(6) % ans = 12 + + +% You can also have subfunctions and nested functions. +% Subfunctions are in the same file as the primary function, and can only be +% called by functions in the file. Nested functions are defined within another +% functions, and have access to both its workspace and their own workspace. + +% If you want to create a function without creating a new file you can use an +% anonymous function. Useful when quickly defining a function to pass to +% another function (eg. plot with fplot, evaluate an indefinite integral +% with quad, find roots with fzero, or find minimum with fminsearch). +% Example that returns the square of it's input, assigned to to the handle sqr: +sqr = @(x) x.^2; +sqr(10) % ans = 100 +doc function_handle % find out more + +% User input +a = input('Enter the value: ') + +% Stops execution of file and gives control to the keyboard: user can examine +% or change variables. Type 'return' to continue execution, or 'dbquit' to exit +keyboard + +% Reading in data (also xlsread/importdata/imread for excel/CSV/image files) +fopen(filename) + +% Output +disp(a) % Print out the value of variable a +disp('Hello World') % Print out a string +fprintf % Print to Command Window with more control + +% Conditional statements (the parentheses are optional, but good style) +if (a > 15) + disp('Greater than 15') +elseif (a == 23) + disp('a is 23') +else + disp('neither condition met') +end + +% Looping +% NB. looping over elements of a vector/matrix is slow! +% Where possible, use functions that act on whole vector/matrix at once +for k = 1:5 + disp(k) +end + +k = 0; +while (k < 5) + k = k + 1; +end + +% Timing code execution: 'toc' prints the time since 'tic' was called +tic +A = rand(1000); +A*A*A*A*A*A*A; +toc + +% Connecting to a MySQL Database +dbname = 'database_name'; +username = 'root'; +password = 'root'; +driver = 'com.mysql.jdbc.Driver'; +dburl = ['jdbc:mysql://localhost:8889/' dbname]; +javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depends on version, download available at http://dev.mysql.com/downloads/connector/j/ +conn = database(dbname, username, password, driver, dburl); +sql = ['SELECT * from table_name where id = 22'] % Example sql statement +a = fetch(conn, sql) %a will contain your data + + +% Common math functions +sin(x) +cos(x) +tan(x) +asin(x) +acos(x) +atan(x) +exp(x) +sqrt(x) +log(x) +log10(x) +abs(x) +min(x) +max(x) +ceil(x) +floor(x) +round(x) +rem(x) +rand % Uniformly distributed pseudorandom numbers +randi % Uniformly distributed pseudorandom integers +randn % Normally distributed pseudorandom numbers + +% Common constants +pi +NaN +inf + +% Solving matrix equations (if no solution, returns a least squares solution) +% The \ and / operators are equivalent to the functions mldivide and mrdivide +x=A\b % Solves Ax=b. Faster and more numerically accurate than using inv(A)*b. +x=b/A % Solves xA=b + +inv(A) % calculate the inverse matrix +pinv(A) % calculate the pseudo-inverse + +% Common matrix functions +zeros(m,n) % m x n matrix of 0's +ones(m,n) % m x n matrix of 1's +diag(A) % Extracts the diagonal elements of a matrix A +diag(x) % Construct a matrix with diagonal elements listed in x, and zeroes elsewhere +eye(m,n) % Identity matrix +linspace(x1, x2, n) % Return n equally spaced points, with min x1 and max x2 +inv(A) % Inverse of matrix A +det(A) % Determinant of A +eig(A) % Eigenvalues and eigenvectors of A +trace(A) % Trace of matrix - equivalent to sum(diag(A)) +isempty(A) % Tests if array is empty +all(A) % Tests if all elements are nonzero or true +any(A) % Tests if any elements are nonzero or true +isequal(A, B) % Tests equality of two arrays +numel(A) % Number of elements in matrix +triu(x) % Returns the upper triangular part of x +tril(x) % Returns the lower triangular part of x +cross(A,B) % Returns the cross product of the vectors A and B +dot(A,B) % Returns scalar product of two vectors (must have the same length) +transpose(A) % Returns the transpose of A +fliplr(A) % Flip matrix left to right +flipud(A) % Flip matrix up to down + +% Matrix Factorisations +[L, U, P] = lu(A) % LU decomposition: PA = LU,L is lower triangular, U is upper triangular, P is permutation matrix +[P, D] = eig(A) % eigen-decomposition: AP = PD, P's columns are eigenvectors and D's diagonals are eigenvalues +[U,S,V] = svd(X) % SVD: XV = US, U and V are unitary matrices, S has non-negative diagonal elements in decreasing order + +% Common vector functions +max % largest component +min % smallest component +length % length of a vector +sort % sort in ascending order +sum % sum of elements +prod % product of elements +mode % modal value +median % median value +mean % mean value +std % standard deviation +perms(x) % list all permutations of elements of x + +``` + +## More on Matlab + +* The official website [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/) +* The official MATLAB Answers forum: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/) + diff --git a/neat.html.markdown b/neat.html.markdown new file mode 100644 index 00000000..f02461ee --- /dev/null +++ b/neat.html.markdown @@ -0,0 +1,297 @@ +--- +language: neat +contributors: + - ["Feep", "https://github.com/FeepingCreature"] +filename: LearnNeat.nt +--- + +Neat is basically a smaller version of D1 with some experimental syntax and a focus on terseness without losing the basic C-like syntax. + +[Read more here.](https://github.com/FeepingCreature/fcc/wiki) + +```c +// single line comments start with // +/* + multiline comments look like this +*/ +/+ + or this + /+ these can be nested too, same as D +/ ++/ + +// Module name. This has to match the filename/directory. +module LearnNeat; + +// Make names from another module visible in this one. +import std.file; +// You can import multiple things at once. +import std.math, std.util; +// You can even group up imports! +import std.(process, socket); + +// Global functions! +void foo() { } + +// Main function, same as in C. +// string[] == "array of strings". +// "string" is just an alias for char[], +void main(string[] args) { + // Call functions with "function expression". + writeln "Hello World"; + // You can do it like in C too... if you really want. + writeln ("Hello World"); + // Declare a variable with "type identifier" + string arg = ("Hello World"); + writeln arg; + // (expression, expression) forms a tuple. + // There are no one-value tuples though. + // So you can always use () in the mathematical sense. + // (string) arg; <- is an error + + /* + byte: 8 bit signed integer + char: 8 bit UTF-8 byte component. + short: 16 bit signed integer + int: 32 bit signed integer + long: 64 bit signed integer + + float: 32 bit floating point + double: 64 bit floating point + real: biggest native size floating point (80 bit on x86). + + bool: true or false + */ + int a = 5; + bool b = true; + // as in C, && and || are short-circuit evaluating. + b = b && false; + assert(b == false); + // "" are "format strings". So $variable will be substituted at runtime + // with a formatted version of the variable. + writeln "$a"; + // This will just print $a. + writeln `$a`; + // you can format expressions with $() + writeln "$(2+2)"; + // Note: there is no special syntax for characters. + char c = "a"; + // Cast values by using type: expression. + // There are three kinds of casts: + // casts that just specify conversions that would be happening automatically + // (implicit casts) + float f = float:5; + float f2 = 5; // would also work + // casts that require throwing away information or complicated computation - + // those must always be done explicitly + // (conversion casts) + int i = int:f; + // int i = f; // would not work! + // and, as a last attempt, casts that just reinterpret the raw data. + // Those only work if the types have the same size. + string s = "Hello World"; + // Arrays are (length, pointer) pairs. + // This is a tuple type. Tuple types are (type, type, type). + // The type of a tuple expression is a tuple type. (duh) + (int, char*) array = (int, char*): s; + // You can index arrays and tuples using the expression[index] syntax. + writeln "pointer is $(array[1]) and length is $(array[0])"; + // You can slice them using the expression[from .. to] syntax. + // Slicing an array makes another array. + writeln "$(s[0..5]) World"; + // Alias name = expression gives the expression a name. + // As opposed to a variable, aliases do not have an address + // and can not be assigned to. (Unless the expression is assignable) + alias range = 0 .. 5; + writeln "$(s[range]) World"; + // You can iterate over ranges. + for int i <- range { + write "$(s[i])"; + } + writeln " World"; + // Note that if "range" had been a variable, it would be 'empty' now! + // Range variables can only be iterated once. + // The syntax for iteration is "expression <- iterable". + // Lots of things are iterable. + for char c <- "Hello" { write "$c"; } + writeln " World"; + // For loops are "for test statement"; + alias test = char d <- "Hello"; + for test write "$d"; + writeln " World\t\x05"; // note: escapes work + // Pointers: function the same as in C, btw. The usual. + // Do note: the pointer star sticks with the TYPE, not the VARIABLE! + string* p; + assert(p == null); // default initializer + p = &s; + writeln "$(*p)"; + // Math operators are (almost) standard. + int x = 2 + 3 * 4 << 5; + // Note: XOR is "xor". ^ is reserved for exponentiation (once I implement that). + int y = 3 xor 5; + int z = 5; + assert(z++ == 5); + assert(++z == 7); + writeln "x $x y $y z $z"; + // As in D, ~ concatenates. + string hewo = "Hello " ~ "World"; + // == tests for equality, "is" tests for identity. + assert (hewo == s); + assert !(hewo is s); + // same as + assert (hewo !is s); + + // Allocate arrays using "new array length" + int[] integers = new int[] 10; + assert(integers.length == 10); + assert(integers[0] == 0); // zero is default initializer + integers = integers ~ 5; // This allocates a new array! + assert(integers.length == 11); + + // This is an appender array. + // Instead of (length, pointer), it tracks (capacity, length, pointer). + // When you append to it, it will use the free capacity if it can. + // If it runs out of space, it reallocates - but it will free the old array automatically. + // This makes it convenient for building arrays. + int[auto~] appender; + appender ~= 2; + appender ~= 3; + appender.free(); // same as {mem.free(appender.ptr); appender = null;} + + // Scope variables are automatically freed at the end of the current scope. + scope int[auto~] someOtherAppender; + // This is the same as: + int[auto~] someOtherAppender2; + onExit { someOtherAppender2.free; } + + // You can do a C for loop too + // - but why would you want to? + for (int i = 0; i < 5; ++i) { } + // Otherwise, for and while are the same. + while int i <- 0..4 { + assert(i == 0); + break; // continue works too + } then assert(false); // if we hadn't break'd, this would run at the end + // This is the height of loopdom - the produce-test-consume loop. + do { + int i = 5; + } while (i == 5) { + assert(i == 5); + break; // otherwise we'd go back up to do { + } + + // This is a nested function. + // Nested functions can access the surrounding function. + string returnS() { return s; } + writeln returnS(); + + // Take the address of a function using & + // The type of a global function is ReturnType function(ParameterTypeTuple). + void function() foop = &foo; + + // Similarly, the type of a nested function is ReturnType delegate(ParameterTypeTuple). + string delegate() returnSp = &returnS; + writeln returnSp(); + // Class member functions and struct member functions also fit into delegate variables. + // In general, delegates are functions that carry an additional context pointer. + // ("fat pointers" in C) + + // Allocate a "snapshot" with "new delegate". + // Snapshots are not closures! I used to call them closures too, + // but then my Haskell-using friends yelled at me so I had to stop. + // The difference is that snapshots "capture" their surrounding context + // when "new" is used. + // This allows things like this + int delegate(int) add(int a) { + int add_a(int b) { return a + b; } + // This does not work - the context of add_a becomes invalid + // when add returns. + // return &add_a; + // Instead: + return new &add_a; + } + int delegate(int) dg = add 2; + assert (dg(3) == 5); + // or + assert (((add 2) 3) == 5); + // or + assert (add 2 3 == 5); + // add can also be written as + int delegate(int) add2(int a) { + // this is an implicit, nameless nested function. + return new λ(int b) { return a + b; } + } + // or even + auto add3(int a) { return new λ(int b) -> a + b; } + // hahahaaa + auto add4 = λ(int a) -> new λ(int b) -> a + b; + assert(add4 2 3 == 5); + // If your keyboard doesn't have a λ (you poor sod) + // you can use \ too. + auto add5 = \(int a) -> new \(int b) -> a + b; + // Note! + auto nestfun = λ() { } // There is NO semicolon needed here! + // "}" can always substitute for "};". + // This provides syntactic consistency with built-in statements. + + + // This is a class. + // Note: almost all elements of Neat can be used on the module level + // or just as well inside a function. + class C { + int a; + void writeA() { writeln "$a"; } + // It's a nested class - it exists in the context of main(). + // so if you leave main(), any instances of C become invalid. + void writeS() { writeln "$s"; } + } + C cc = new C; + // cc is a *reference* to C. Classes are always references. + cc.a = 5; // Always used for property access. + auto ccp = &cc; + (*ccp).a = 6; + // or just + ccp.a = 7; + cc.writeA(); + cc.writeS(); // to prove I'm not making things up + // Interfaces work same as in D, basically. Or Java. + interface E { void doE(); } + // Inheritance works same as in D, basically. Or Java. + class D : C, E { + override void writeA() { writeln "hahahahaha no"; } + override void doE() { writeln "eeeee"; } + // all classes inherit from Object. (toString is defined in Object) + override string toString() { return "I am a D"; } + } + C cd = new D; + // all methods are always virtual. + cd.writeA(); + E e = E:cd; // dynamic class cast! + e.doE(); + writeln "$e"; // all interfaces convert to Object implicitly. + + // Templates! + // Templates are parameterized namespaces, taking a type as a parameter. + template Templ(T) { + alias hi = 5, hii = 8; + // Templates always have to include something with the same name as the template + // - this will become the template's _value_. + // Static ifs are evaluated statically, at compile-time. + // Because of this, the test has to be a constant expression, + // or something that can be optimized to a constant. + static if (types-equal (T, int)) { + alias Templ = hi; + } else { + alias Templ = hii; + } + } + assert(Templ!int == 5); + assert(Templ!float == 8); +} +``` + +## Topics Not Covered + + * Extended iterator types and expressions + * Standard library + * Conditions (error handling) + * Macros diff --git a/nim.html.markdown b/nim.html.markdown new file mode 100644 index 00000000..c9548a1c --- /dev/null +++ b/nim.html.markdown @@ -0,0 +1,273 @@ +--- +language: Nim +filename: learnNim.nim +contributors: + - ["Jason J. Ayala P.", "http://JasonAyala.com"] + - ["Dennis Felsing", "http://felsin9.de/nnis/"] +--- + +Nim (formerly Nimrod) is a statically typed, imperative programming language +that gives the programmer power without compromises on runtime efficiency. + +Nim is efficient, expressive, and elegant. + +```nimrod +var # Declare (and assign) variables, + letter: char = 'n' # with or without type annotations + lang = "N" & "im" + nLength : int = len(lang) + boat: float + truth: bool = false + +let # Use let to declare and bind variables *once*. + legs = 400 # legs is immutable. + arms = 2_000 # _ are ignored and are useful for long numbers. + aboutPi = 3.15 + +const # Constants are computed at compile time. This provides + debug = true # performance and is useful in compile time expressions. + compileBadCode = false + +when compileBadCode: # `when` is a compile time `if` + legs = legs + 1 # This error will never be compiled. + const input = readline(stdin) # Const values must be known at compile time. + +discard 1 > 2 # Note: The compiler will complain if the result of an expression + # is unused. `discard` bypasses this. + +discard """ +This can work as a multiline comment. +Or for unparsable, broken code +""" + +# +# Data Structures +# + +# Tuples + +var + child: tuple[name: string, age: int] # Tuples have *both* field names + today: tuple[sun: string, temp: float] # *and* order. + +child = (name: "Rudiger", age: 2) # Assign all at once with literal () +today.sun = "Overcast" # or individual fields. +today.temp = 70.1 + +# Sequences + +var + drinks: seq[string] + +drinks = @["Water", "Juice", "Chocolate"] # @[V1,..,Vn] is the sequence literal + +drinks.add("Milk") + +if "Milk" in drinks: + echo "We have Milk and ", drinks.len - 1, " other drinks" + +let myDrink = drinks[2] + +# +# Defining Types +# + +# Defining your own types puts the compiler to work for you. It's what makes +# static typing powerful and useful. + +type + Name = string # A type alias gives you a new type that is interchangable + Age = int # with the old type but is more descriptive. + Person = tuple[name: Name, age: Age] # Define data structures too. + AnotherSyntax = tuple + fieldOne: string + secondField: int + +var + john: Person = (name: "John B.", age: 17) + newage: int = 18 # It would be better to use Age than int + +john.age = newage # But still works because int and Age are synonyms + +type + Cash = distinct int # `distinct` makes a new type incompatible with its + Desc = distinct string # base type. + +var + money: Cash = 100.Cash # `.Cash` converts the int to our type + description: Desc = "Interesting".Desc + +when compileBadCode: + john.age = money # Error! age is of type int and money is Cash + john.name = description # Compiler says: "No way!" + +# +# More Types and Data Structures +# + +# Enumerations allow a type to have one of a limited number of values + +type + Color = enum cRed, cBlue, cGreen + Direction = enum # Alternative formating + dNorth + dWest + dEast + dSouth +var + orient = dNorth # `orient` is of type Direction, with the value `dNorth` + pixel = cGreen # `pixel` is of type Color, with the value `cGreen` + +discard dNorth > dEast # Enums are usually an "ordinal" type + +# Subranges specify a limited valid range + +type + DieFaces = range[1..20] # Only an int from 1 to 20 is a valid value +var + my_roll: DieFaces = 13 + +when compileBadCode: + my_roll = 23 # Error! + +# Arrays + +type + RollCounter = array[DieFaces, int] # Array's are fixed length and + DirNames = array[Direction, string] # indexed by any ordinal type. + Truths = array[42..44, bool] +var + counter: RollCounter + directions: DirNames + possible: Truths + +possible = [false, false, false] # Literal arrays are created with [V1,..,Vn] +possible[42] = true + +directions[dNorth] = "Ahh. The Great White North!" +directions[dWest] = "No, don't go there." + +my_roll = 13 +counter[my_roll] += 1 +counter[my_roll] += 1 + +var anotherArray = ["Default index", "starts at", "0"] + +# More data structures are available, including tables, sets, lists, queues, +# and crit bit trees. +# http://nim-lang.org/docs/lib.html#collections-and-algorithms + +# +# IO and Control Flow +# + +# `case`, `readLine()` + +echo "Read any good books lately?" +case readLine(stdin) +of "no", "No": + echo "Go to your local library." +of "yes", "Yes": + echo "Carry on, then." +else: + echo "That's great; I assume." + +# `while`, `if`, `continue`, `break` + +import strutils as str # http://nim-lang.org/docs/strutils.html +echo "I'm thinking of a number between 41 and 43. Guess which!" +let number: int = 42 +var + raw_guess: string + guess: int +while guess != number: + raw_guess = readLine(stdin) + if raw_guess == "": continue # Skip this iteration + guess = str.parseInt(raw_guess) + if guess == 1001: + echo("AAAAAAGGG!") + break + elif guess > number: + echo("Nope. Too high.") + elif guess < number: + echo(guess, " is too low") + else: + echo("Yeeeeeehaw!") + +# +# Iteration +# + +for i, elem in ["Yes", "No", "Maybe so"]: # Or just `for elem in` + echo(elem, " is at index: ", i) + +for k, v in items(@[(person: "You", power: 100), (person: "Me", power: 9000)]): + echo v + +let myString = """ +an <example> +`string` to +play with +""" # Multiline raw string + +for line in splitLines(myString): + echo(line) + +for i, c in myString: # Index and letter. Or `for j in` for just letter + if i mod 2 == 0: continue # Compact `if` form + elif c == 'X': break + else: echo(c) + +# +# Procedures +# + +type Answer = enum aYes, aNo + +proc ask(question: string): Answer = + echo(question, " (y/n)") + while true: + case readLine(stdin) + of "y", "Y", "yes", "Yes": + return Answer.aYes # Enums can be qualified + of "n", "N", "no", "No": + return Answer.aNo + else: echo("Please be clear: yes or no") + +proc addSugar(amount: int = 2) = # Default amount is 2, returns nothing + assert(amount > 0 or amount < 9000, "Crazy Sugar") + for a in 1..amount: + echo(a, " sugar...") + +case ask("Would you like sugar in your tea?") +of aYes: + addSugar(3) +of aNo: + echo "Oh do take a little!" + addSugar() +# No need for an `else` here. Only `yes` and `no` are possible. + +# +# FFI +# + +# Because Nim compiles to C, FFI is easy: + +proc strcmp(a, b: cstring): cint {.importc: "strcmp", nodecl.} + +let cmp = strcmp("C?", "Easy!") +``` + +Additionally, Nim separates itself from its peers with metaprogramming, +performance, and compile-time features. + +## Further Reading + +* [Home Page](http://nim-lang.org) +* [Download](http://nim-lang.org/download.html) +* [Community](http://nim-lang.org/community.html) +* [FAQ](http://nim-lang.org/question.html) +* [Documentation](http://nim-lang.org/documentation.html) +* [Manual](http://nim-lang.org/docs/manual.html) +* [Standard Library](http://nim-lang.org/docs/lib.html) +* [Rosetta Code](http://rosettacode.org/wiki/Category:Nim) diff --git a/nl-nl/brainfuck-nl.html.markdown b/nl-nl/brainfuck-nl.html.markdown new file mode 100644 index 00000000..cd12b1d0 --- /dev/null +++ b/nl-nl/brainfuck-nl.html.markdown @@ -0,0 +1,86 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Jelle Besseling", "https://github.com/Jell-E"] +lang: nl-nl +--- + +Brainfuck (schrijf je niet met een hoofdletter behalve aan het begin van een +zin) is een extreem +minimalistische Turing-complete programmeertaal met maar acht commando's. + +``` +Elk karakter behalve "><+-.,[]" (en de quotes) wordt genegeerd. + +Brainfuck wordt gerepresenteerd door een array met 30,000 cellen die initieel +gevuld is met nullen en een pointer die wijst naar de huidige cel. + +Dit zijn de acht commando's: ++ : Verhoog de huidige cell met 1. +- : Verminder de huidige cell met 1. +> : Beweeg de pointer naar de volgende cell (één naar rechts). +< : Beweeg de pointer naar de vorige cell (één naar links). +. : Print de huidige cell als een ASCII karakter(d.w.z. 65 = 'A'). +, : Lees een karakter in de huidige cell. +[ : Als de huidige cell nul is ga dan naar de bijbehorende ] . + Als het geen nul is, ga dan gewoon verder. +] : Als de huidige cell nul is ga dan gewoon verder. + Als het geen nul is, ga dan terug naar de bijbehorende [ . + +[ en ] maken een while loop. Ze moeten uiteraard wel gebalanceerd zijn + +Laten we een kijkje nemen naar een paar brainfuck programma's. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Dit programma print het karakter 'A'. Eerst verhoogt het cell #1 tot 6. +Cell #1 wordt gebruikt om te loopen. Dan begint het de loop ([) en gaat +naar cell #2. Het verhoogt cell #2 tien keer, gaat terug naar cell #1, en +verlaagt cell #1. Deze loop gebeurt zes keer (na zes keer staat cell #1 +weer op nul, waarna het doorgaat naar het einde van de loop (]) en +verder gaat). + +De pointer staat nu weer op cell #1, deze heeft een waarde van 0, en cell #2 +heeft een waarde van 60. > beweegt de pointer naar cell #2, daarna verhoogt +het de cell vijf keer, waardoor het een waarde van 65 bevat, en print dan +de waarde van cell #2. 65 is 'A' in ASCII, dus 'A' wordt geprint in de terminal. + + +, [ > + < - ] > . + +Dit programma leest een karakter van de gebruiker in put en kopieert dat +karakter in cel #1. Dan start de loop. Ga naar cel #2, verhoog de waarde in +cel #2, ga terug naar cel #1, en verklein de waarde in cel #1. Dit gaat door +totdat cel #1 nul is en cel #2 de oude waarde heeft van cell #1. Omdat we +op cel #1 staan verplaatst > de pointer één naar rechts en . print het +karakter in cel #2. + +Houd wel in gedachten dat de spaties alleen zijn voor leesbaarheid, je kan het +bovenstaande programma net zo goed schrijven als: + +,[>+<-]>. + +Probeer maar eens te bedenken wat het volgende programma doet: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Dit programma neemt twee getallen als input, en vermenigvuldigt ze. + +In het begin leest het twee karakters in cel #1 en #2. Dan start het de +buitenste loop, met als teller cel #1. Het beweegt naar cel #2, dan start het +de binnenste loop met als teller cel #2, daar verhoogd het cel #3. Maar +dan is er een probleem als cel #2 nul wordt aan het einde van de binnenste loop. +Om dit op te lossen wordt ook cel #4 verhoogd naar het oorspronkelijke getal +uit cel #2 en daarna wordt cel #4 weer gekopieerd naar cell #2. +Het resultaat komt in cel #3 te staan. +``` + +En dat is dan brainfuck. Niet heel moeilijk, toch? Je kan zelf voor de lol +brainfuck programma's gaan schrijven, of je kan een interpreter schrijven +voor brainfuck in een andere taal. Het is namelijk redelijk makkelijk om te +implementeren aangezien brainfuck maar acht commando's heeft. En als je een +masochist bent kan je ook nog proberen om brainfuck te implementeren… in +brainfuck. diff --git a/nl-nl/coffeescript-nl.html.markdown b/nl-nl/coffeescript-nl.html.markdown new file mode 100644 index 00000000..dc0b1e19 --- /dev/null +++ b/nl-nl/coffeescript-nl.html.markdown @@ -0,0 +1,110 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Jelle Besseling", "https://github.com/Jell-E"] + - ["D.A.W. de Waal", "http://github.com/diodewaal"] +filename: coffeescript-nl.coffee +lang: nl-nl +--- + +CoffeeScript is een kleine programmeertaal die direct compileert naar +JavaScript en er is geen interpretatie tijdens het uitvoeren. +CoffeeScript probeert om leesbare, goed geformatteerde en goed draaiende +JavaScript code te genereren, die in elke JavaScript runtime werkt, als een +opvolger van JavaScript. + +Op [de CoffeeScript website](http://coffeescript.org/), staat een +volledigere tutorial voor CoffeeScript. + +``` coffeescript +# CoffeeScript is een taal voor hipsters. +# Het gaat mee met alle trends van moderne talen. +# Commentaar begint dus met een hekje, net zoals bij Python en Ruby. + +### +Blokken commentaar maak je zo, ze vertalen naar JavaScripts */ en /* +in de uitvoer van de CoffeeScript compiler. + +Het is belangrijk dat je ongeveer snapt hoe JavaScript +werkt voordat je verder gaat. +### + +# Toewijzing: +getal = 42 #=> var getal = 42; +tegengestelde = true #=> var tegengestelde = true; + +# Voorwaarden: +getal = -42 if tegengestelde #=> if(tegengestelde) { getal = -42; } + +# Functies: +kwadraat = (x) -> x * x #=> var kwadraat = function(x) { return x * x; } + +vul = (houder, vloeistof = "koffie") -> + "Nu de #{houder} met #{koffie} aan het vullen..." +#=>var vul; +# +#vul = function(houder, vloeistof) { +# if (vloeistof == null) { +# vloeistof = "koffie"; +# } +# return "Nu de " + houder + " met " + vloeistof + " aan het vullen..."; +#}; + +# Reeksen: +lijst = [1..5] #=> var lijst = [1, 2, 3, 4, 5]; + +# Objecten: +wiskunde = + wortel: Math.sqrt + kwadraat: kwadraat + derdemacht: (x) -> x * kwadraat x +#=> var wiskunde = { +# "wortel": Math.sqrt, +# "kwadraat": kwadraat, +# "derdemacht": function(x) { return x * kwadraat(x); } +#} + +# "Splats": +wedstrijd = (winnaar, lopers...) -> + print winnaar, lopers +#=>wedstrijd = function() { +# var lopers, winnaar; +# winnaar = arguments[0], lopers = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(winnaar, lopers); +#}; + +# Aanwezigheid: +alert "Ik wist het!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# Lijst abstractie: +derdemachten = (wiskunde.derdemacht num for num in lijst) +#=>derdemachten = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = lijst.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(wiskunde.derdemacht(num)); +# } +# return _results; +# })(); + +etenswaren = ['broccoli', 'spinazie', 'chocolade'] +eet eten for eten in etenswaren when eten isnt 'chocolade' +#=>etenswaren = ['broccoli', 'spinazie', 'chocolade']; +# +#for (_k = 0, _len2 = etenswaren.length; _k < _len2; _k++) { +# eten = etenswaren[_k]; +# if (eten !== 'chocolade') { +# eet(eten); +# } +#} +``` + +## Handige links (in het Engels): + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) diff --git a/no-nb/bash-no.html.markdown b/no-nb/bash-no.html.markdown new file mode 100644 index 00000000..ab0c064f --- /dev/null +++ b/no-nb/bash-no.html.markdown @@ -0,0 +1,270 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] +filename: LearnBash-no.sh +translators: + - ["Andreas Lindahl Flåten", "https://github.com/anlif"] +lang: no-nb +--- +Bash er navnet på unix skallet, som også var distribuert som skallet for GNU +operativsystemet og som standard skall på de fleste Linux distribusjoner og +Mac OS X. + +[Les mer her.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Den første linjen i et bash skript starter med '#!' (shebang) +# etterfulgt av stien til bash http://en.wikipedia.org/wiki/Shebang_(Unix) +# Kommentarer starter med #. + +# Enkelt hello world eksempel: +echo Hello world! + +# Hver kommando starter på en ny linje, eller etter et semikolon: +echo 'Dette er den første linjen'; echo 'Dette er en andre linjen' + +# Deklarering av en variabel ser slik ut: +VARIABLE="En tekststreng" + +# Men ikke slik: +VARIABLE = "En tekststreng" +# Bash vil tolke dette som at VARIABLE er en kommando den skal kjøre +# og gi en feilmelding dersom kommandoen ikke finnes + +# Bruk av den nydeklarerte variabelen: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Når du bruker variabelen, for eksempel setter verdien eller eksporterer den, +# skriver du navnet dens uten $. Hvis du vil bruke variabelens verdi, +# skriver du $ før variabelnavnet. + +# Strenginnhold i en variabel kan erstattes på følgende måte: +echo ${VARIABLE/tull/ball} +# Dette vil erstatte første forekomst av 'tull' med 'ball' + +# Substreng av en variabel: +echo ${VARIABLE:0:7} +# Dette vil returnere de første 7 tegnene i en strengvariabel + +# Å angi en standardverdi dersom en variabel er udeklarert gjøres slik: +echo ${FOO:-"StandardVerdiDersomFOOErTom"} +# Dette fungerer for null (FOO=), tom streng (FOO="") og tallet null (FOO=0) + +# Det finnes en rekke hendige innebygde variable, eksempel: +echo "Siste programs returnerte verdi: $?" +echo "Skript's PID: $$" +echo "Antall argumenter: $#" +echo "Alle argumenter til skriptet: $@" +echo "Argumenter til skriptet i egne variable: $1 $2..." + +# Lesing av input: +echo "Hva heter du?" +read NAME # variabelen NAME blir automatisk deklarert av 'read' kommandoen +echo Hei, $NAME! + +# if setninger ser slik ut: +# se 'man test' for mer informasjon om betingelser +if [ $NAME -ne $USER ] +then + echo "Your name isn't your username" +else + echo "Your name is your username" +fi + +# Det finnes også betinget eksekvering +echo "Kjøres alltid" || echo "Kjøres kun dersom første kommando feilet" +echo "Kjøres alltid" && echo "Kjøres kun dersom første kommando IKKE feilet" + +# For å bruke && (logisk OG) og || (logisk ELLER) sammen med if setninger, +# trenger man par av firkantklammer [] på hver side av et logisk uttrykk: +if [ $NAME == "Steve" ] && [ $AGE -eq 15 ] +then + echo "Dette kjører dersom $NAME er Steve OG $AGE er lik 15." +fi + +if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ] +then + echo "Dette kjører dersom $NAME er Daniya ELLER Zach." +fi + +# Matematiske uttrykk skrives slik: +echo $(( 10 + 5 )) + +# Ulikt de fleste programmeringsspråk, så er bash et skall - det medfører at en +# kommando i et skript kjører i en bestemt mappe i filsystemet. Du kan skrive +# ut innholdet i nåværende mappe med ls kommandoen: +ls + +# Kommandoen har parametre som kontrollerer hvordan kommandoen utføres: +ls -l # Skriv hver fil og mappe på sin egen linje + +# Resultatet av forrige kommando kan bli sendt til neste kommando som input. +# grep kommandoen filtrerer input ved hjelp av et regulært uttrykk. +# Ved å bruke grep kan vi skrive ut kun .txt filer på følgende måte: +ls -l | grep "\.txt" # lær mer om grep ved å skrive 'man grep' + +# Input og output fra filer kan dirigeres (stdin, stdout og stderr). +# 'cat' kommandoen uten argumenter skriver fra stdin til stdout. +# I det følgende eksempelet overskrives filen hello.py med linjene mellom EOF. +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Kjør hello.py (et python skript) +# med ulike stdin, stdout, and stderr omdirigeringer: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# '>' operatoren overskriver filen dersom den finnes. +# Hvis du heller vil legge til på slutten av en eksisterende fil, bruk '>>' +python hello.py >> "output.out" 2>> "error.err" + +# Overskriv output.txt, legg til error.err, og tell antall linjer med 'wc': +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Run a command and print its file descriptor (e.g. /dev/fd/123) +# Kjør en kommando og print tilhørende 'file descriptor' +# se 'man fd' +echo <(echo "#helloworld") + +# Ulike måter å overskrive output.out med '#helloworld': +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Slett noen filer med økt verbositet '-v', legg til '-i' for interaktiv modus +rm -v output.out error.err output-and-error.log + +# Kommandoer kan kjøres i deklarasjonen av andre kommandoer ved å bruke $( ): +# Følgende kommando skriver antall filer og mapper i nåværende mappe +echo "There are $(ls | wc -l) items here." + +# Det samme kan gjøres med backticks `` men de kan ikke være nøstede, +# det anbefales å bruke $( ) slik som i forrige eksempel. +echo "There are `ls | wc -l` items here." + +# Bash har en 'case' setning som fungerer omtrent som en 'switch' i Java/C: +case "$VARIABLE" in + # Skriv ønskede match med tilhørende kommandoer + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# for løkker kan iterere over en mengde argumenter: +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# Eller vi kan skrive en for løkke omtrent slik det kan gjøres i Java/C: +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Man kan også iterere over resultatet av en annen kommando. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# while løkke, se if setninger: +while [ true ] +do + echo "loop body here..." + break +done + +# Man kan også definere funksjoner. +# Definisjon: +function foo () +{ + echo "Argumenter fungerer akkurat som skript argumenter: $@" + echo "Og: $1 $2..." + echo "Dette er en funksjon" + return 0 +} + +# eller bare: +bar () +{ + echo "En annen måte å deklarere en funksjon." + return 0 +} + +# Å kalle en funksjon: +foo "Mitt navn er" $NAME + +# There are a lot of useful commands you should learn: +# prints last 10 lines of file.txt +# Det er mange nyttige kommandoer du bør lære deg: +# "tail" skriver ut slutten av en fil, i dette tilfellet de siste 10 linjene +tail -n 10 file.txt +# skriv ut de første 10 linjene av file.txt +head -n 10 file.txt +# sorter linjene i file.txt ("man sort") +sort file.txt +# skriv ut eller fjern repeterte linjer, med -d skrives de ut +uniq -d file.txt +# skriver kun den første kolonnen før ',' tegnet +cut -d ',' -f 1 file.txt +# erstatter hvert tilfelle av 'bjarne' med 'alfa' i file.txt, +# sed støtter regulære uttrykk ("man sed"). +sed -i 's/bjarne/alfa/g' file.txt +# skriv til stdout alle linjer i file.txt som matches av et regulært uttrykk +# eksempelet skriver ut alle linjer som begynner med "foo" og slutter med "bar" +grep "^foo.*bar$" file.txt +# skriv "-c" hvis du heller vil vite antall linjer som matcher +grep -c "^foo.*bar$" file.txt +# hvis du vil matche en bestemt streng, og ikke et regulært uttrykk +# bruker du enten "fgrep" eller ekvivalenten "grep -f" +fgrep "^foo.*bar$" file.txt + + +# Les Bash sin egen dokumentasjon om innebygde konstruksjoner: +help +help help +help for +help return +help source +help . + +# Les Bash sin "manpage": +apropos bash +man 1 bash +man bash + +# Les "info" dokumentasjon: +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Les bash sin info dokumentasjon: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/objective-c.html.markdown b/objective-c.html.markdown new file mode 100644 index 00000000..89901308 --- /dev/null +++ b/objective-c.html.markdown @@ -0,0 +1,755 @@ +--- + +language: Objective-C +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 + +--- + +Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch. +It is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. + +```objective_c +// Single-line comments start with // + +/* +Multi-line comments look like this +*/ + +// Imports the Foundation headers with #import +// Use <> to import global files (in general frameworks) +// Use "" to import local files (from project) +#import <Foundation/Foundation.h> +#import "MyClass.h" + +// If you enable modules for iOS >= 7.0 or OS X >= 10.9 projects in +// Xcode 5 you can import frameworks like that: +@import Foundation; + +// Your program's entry point is a function called +// main with an integer return type +int main (int argc, const char * argv[]) +{ + // Create an autorelease pool to manage the memory into the program + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + // If using automatic reference counting (ARC), use @autoreleasepool instead: + @autoreleasepool { + + // Use NSLog to print lines to the console + NSLog(@"Hello World!"); // Print the string "Hello World!" + + /////////////////////////////////////// + // Types & Variables + /////////////////////////////////////// + + // Primitive declarations + int myPrimitive1 = 1; + long myPrimitive2 = 234554664565; + + // Object declarations + // Put the * in front of the variable names for strongly-typed object declarations + MyClass *myObject1 = nil; // Strong typing + id myObject2 = nil; // Weak typing + // %@ is an object + // 'description' is a convention to display the value of the Objects + NSLog(@"%@ and %@", myObject1, [myObject2 description]); // prints => "(null) and (null)" + + // String + NSString *worldString = @"World"; + NSLog(@"Hello %@!", worldString); // prints => "Hello World!" + // NSMutableString is a mutable version of the NSString object + NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"]; + [mutableString appendString:@" World!"]; + NSLog(@"%@", mutableString); // prints => "Hello World!" + + // Character literals + NSNumber *theLetterZNumber = @'Z'; + char theLetterZ = [theLetterZNumber charValue]; // or 'Z' + NSLog(@"%c", theLetterZ); + + // Integral literals + NSNumber *fortyTwoNumber = @42; + int fortyTwo = [fortyTwoNumber intValue]; // or 42 + NSLog(@"%i", fortyTwo); + + NSNumber *fortyTwoUnsignedNumber = @42U; + unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // or 42 + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42]; + short fortyTwoShort = [fortyTwoShortNumber shortValue]; // or 42 + NSLog(@"%hi", fortyTwoShort); + + NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41]; + unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // or 41 + NSLog(@"%u", fortyOneUnsigned); + + NSNumber *fortyTwoLongNumber = @42L; + long fortyTwoLong = [fortyTwoLongNumber longValue]; // or 42 + NSLog(@"%li", fortyTwoLong); + + NSNumber *fiftyThreeLongNumber = @53L; + unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // or 53 + NSLog(@"%lu", fiftyThreeUnsigned); + + // Floating point literals + NSNumber *piFloatNumber = @3.141592654F; + float piFloat = [piFloatNumber floatValue]; // or 3.141592654f + NSLog(@"%f", piFloat); // prints => 3.141592654 + NSLog(@"%5.2f", piFloat); // prints => " 3.14" + + NSNumber *piDoubleNumber = @3.1415926535; + double piDouble = [piDoubleNumber doubleValue]; // or 3.1415926535 + NSLog(@"%f", piDouble); + NSLog(@"%4.2f", piDouble); // prints => "3.14" + + // NSDecimalNumber is a fixed-point class that's more precise then float or double + NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"]; + NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"]; + // NSDecimalNumber isn't able to use standard +, -, *, / operators so it provides its own: + [oneDecNum decimalNumberByAdding:twoDecNum]; + [oneDecNum decimalNumberBySubtracting:twoDecNum]; + [oneDecNum decimalNumberByMultiplyingBy:twoDecNum]; + [oneDecNum decimalNumberByDividingBy:twoDecNum]; + NSLog(@"%@", oneDecNum); // prints => 10.99 as NSDecimalNumber is immutable + + // BOOL literals + NSNumber *yesNumber = @YES; + NSNumber *noNumber = @NO; + // or + BOOL yesBool = YES; + BOOL noBool = NO; + NSLog(@"%i", yesBool); // prints => 1 + + // Array object + // May contain different data types, but must be an Objective-C object + NSArray *anArray = @[@1, @2, @3, @4]; + NSNumber *thirdNumber = anArray[2]; + NSLog(@"Third number = %@", thirdNumber); // prints => "Third number = 3" + // NSMutableArray is a mutable version of NSArray, allowing you to change + // the items in the array and to extend or shrink the array object. + // Convenient, but not as efficient as NSArray. + NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2]; + [mutableArray addObject:@"Hello"]; + [mutableArray addObject:@"World"]; + [mutableArray removeObjectAtIndex:0]; + NSLog(@"%@", [mutableArray objectAtIndex:0]); // prints => "World" + + // Dictionary object + NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" }; + NSObject *valueObject = aDictionary[@"A Key"]; + NSLog(@"Object = %@", valueObject); // prints => "Object = (null)" + // NSMutableDictionary also available as a mutable dictionary object + NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2]; + [mutableDictionary setObject:@"value1" forKey:@"key1"]; + [mutableDictionary setObject:@"value2" forKey:@"key2"]; + [mutableDictionary removeObjectForKey:@"key1"]; + + // Set object + NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil]; + NSLog(@"%@", set); // prints => {(Hello, World)} (may be in different order) + // NSMutableSet also available as a mutable set object + NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2]; + [mutableSet addObject:@"Hello"]; + [mutableSet addObject:@"Hello"]; + NSLog(@"%@", mutableSet); // prints => {(Hello)} + + /////////////////////////////////////// + // Operators + /////////////////////////////////////// + + // The operators works like in the C language + // For example: + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (NO) + 3 != 2; // => 1 (YES) + 1 && 1; // => 1 (Logical and) + 0 || 1; // => 1 (Logical or) + ~0x0F; // => 0xF0 (bitwise negation) + 0x0F & 0xF0; // => 0x00 (bitwise AND) + 0x01 << 1; // => 0x02 (bitwise left shift (by 1)) + + /////////////////////////////////////// + // Control Structures + /////////////////////////////////////// + + // If-Else statement + if (NO) + { + NSLog(@"I am never run"); + } else if (0) + { + NSLog(@"I am also never run"); + } else + { + NSLog(@"I print"); + } + + // Switch statement + switch (2) + { + case 0: + { + NSLog(@"I am never run"); + } break; + case 1: + { + NSLog(@"I am also never run"); + } break; + default: + { + NSLog(@"I print"); + } break; + } + + // While loops statements + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++ increments ii in-place, after using its value + } // prints => "0," + // "1," + // "2," + // "3," + + // For loops statements + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj); + } // prints => "0," + // "1," + // "2," + // "3," + + // Foreach statements + NSArray *values = @[@0, @1, @2, @3]; + for (NSNumber *value in values) + { + NSLog(@"%@,", value); + } // prints => "0," + // "1," + // "2," + // "3," + + // Object for loop statement. Can be used with any Objective-C object type + for (id item in values) { + NSLog(@"%@,", item); + } // prints => "0," + // "1," + // "2," + // "3," + + // Try-Catch-Finally statements + @try + { + // Your statements here + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"File Not Found on System" userInfo:nil]; + } @catch (NSException * e) // use: @catch (id exceptionName) to catch all objects. + { + NSLog(@"Exception: %@", e); + } @finally + { + NSLog(@"Finally. Time to clean up."); + } // prints => "Exception: File Not Found on System" + // "Finally. Time to clean up." + + // NSError objects are useful for function arguments to populate on user mistakes. + NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil]; + + /////////////////////////////////////// + // Objects + /////////////////////////////////////// + + // Create an object instance by allocating memory and initializing it + // An object is not fully functional until both steps have been completed + MyClass *myObject = [[MyClass alloc] init]; + + // The Objective-C model of object-oriented programming is based on message + // passing to object instances + // In Objective-C one does not simply call a method; one sends a message + [myObject instanceMethodWithParameter:@"Steve Jobs"]; + + // Clean up the memory you used into your program + [pool drain]; + + // End of @autoreleasepool + } + + // End the program + return 0; +} + +/////////////////////////////////////// +// Classes And Functions +/////////////////////////////////////// + +// Declare your class in a header file (MyClass.h): +// Class declaration syntax: +// @interface ClassName : ParentClassName <ImplementedProtocols> +// { +// type name; <= variable declarations; +// } +// @property type name; <= property declarations +// -/+ (type) Method declarations; <= Method declarations +// @end +@interface MyClass : NSObject <MyProtocol> // NSObject is Objective-C's base object class. +{ + // Instance variable declarations (can exist in either interface or implementation file) + int count; // Protected access by default. + @private id data; // Private access (More convenient to declare in implementation file) + NSString *name; +} +// Convenient notation for public access variables to auto generate a setter method +// By default, setter method name is 'set' followed by @property variable name +@property int propInt; // Setter method name = 'setPropInt' +@property (copy) id copyId; // (copy) => Copy the object during assignment +// (readonly) => Cannot set value outside @interface +@property (readonly) NSString *roString; // Use @synthesize in @implementation to create accessor +// You can customize the getter and setter names instead of using default 'set' name: +@property (getter=lengthGet, setter=lengthSet:) int length; + +// Methods ++/- (return type)methodSignature:(Parameter Type *)parameterName; + +// + for class methods: ++ (NSString *)classMethod; ++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight; + +// - for instance methods: +- (NSString *)instanceMethodWithParameter:(NSString *)string; +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number; + +// Constructor methods with arguments: +- (id)initWithDistance:(int)defaultDistance; +// Objective-C method names are very descriptive. Always name methods according to their arguments + +@end // States the end of the interface + + +// To access public variables from the implementation file, @property generates a setter method +// automatically. Method name is 'set' followed by @property variable name: +MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance +[myClass setCount:10]; +NSLog(@"%d", [myClass count]); // prints => 10 +// Or using the custom getter and setter method defined in @interface: +[myClass lengthSet:32]; +NSLog(@"%i", [myClass lengthGet]); // prints => 32 +// For convenience, you may use dot notation to set and access object instance variables: +myClass.count = 45; +NSLog(@"%i", myClass.count); // prints => 45 + +// Call class methods: +NSString *classMethodString = [MyClass classMethod]; +MyClass *classFromName = [MyClass myClassFromName:@"Hello"]; + +// Call instance methods: +MyClass *myClass = [[MyClass alloc] init]; // Create MyClass object instance +NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"]; + +// Selectors +// Way to dynamically represent methods. Used to call methods of a class, pass methods +// through functions to tell other classes they should call it, and to save methods +// as a variable +// SEL is the data type. @selector() returns a selector from method name provided +// methodAParameterAsString:andAParameterAsNumber: is method name for method in MyClass +SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:); +if ([myClass respondsToSelector:selectorVar]) { // Checks if class contains method + // Must put all method arguments into one object to send to performSelector function + NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; + [myClass performSelector:selectorVar withObject:arguments]; // Calls the method +} else { + // NSStringFromSelector() returns a NSString of the method name of a given selector + NSLog(@"MyClass does not have method: %@", NSStringFromSelector(selectedVar)); +} + +// Implement the methods in an implementation (MyClass.m) file: +@implementation MyClass { + long distance; // Private access instance variable + NSNumber height; +} + +// To access a public variable from the interface file, use '_' followed by variable name: +_count = 5; // References "int count" from MyClass interface +// Access variables defined in implementation file: +distance = 18; // References "long distance" from MyClass implementation +// To use @property variable in implementation, use @synthesize to create accessor variable: +@synthesize roString = _roString; // _roString available now in @implementation + +// Called before calling any class methods or instantiating any objects ++ (void)initialize +{ + if (self == [MyClass class]) { + distance = 0; + } +} + +// Counterpart to initialize method. Called when an object's reference count is zero +- (void)dealloc +{ + [height release]; // If not using ARC, make sure to release class variable objects + [super dealloc]; // and call parent class dealloc +} + +// Constructors are a way of creating instances of a class +// This is a default constructor which is called when the object is initialized. +- (id)init +{ + if ((self = [super init])) // 'super' used to access methods from parent class + { + self.count = 1; // 'self' used for object to call itself + } + return self; +} +// Can create constructors that contain arguments: +- (id)initWithDistance:(int)defaultDistance +{ + distance = defaultDistance; + return self; +} + ++ (NSString *)classMethod +{ + return @"Some string"; +} + ++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight +{ + height = defaultHeight; + return [[self alloc] init]; +} + +- (NSString *)instanceMethodWithParameter:(NSString *)string +{ + return @"New string"; +} + +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number +{ + return @42; +} + +// Objective-C does not have private method declarations, but you can simulate them. +// To simulate a private method, create the method in the @implementation but not in the @interface. +- (NSNumber *)secretPrivateMethod { + return @72; +} +[self secretPrivateMethod]; // Calls private method + +// Methods declared into MyProtocol +- (void)myProtocolMethod +{ + // statements +} + +@end // States the end of the implementation + +/////////////////////////////////////// +// Categories +/////////////////////////////////////// +// A category is a group of methods designed to extend a class. They allow you to add new methods +// to an existing class for organizational purposes. This is not to be mistaken with subclasses. +// Subclasses are meant to CHANGE functionality of an object while categories instead ADD +// functionality to an object. +// Categories allow you to: +// -- Add methods to an existing class for organizational purposes. +// -- Allow you to extend Objective-C object classes (ex: NSString) to add your own methods. +// -- Add ability to create protected and private methods to classes. +// NOTE: Do not override methods of the base class in a category even though you have the ability +// to. Overriding methods may cause compiler errors later between different categories and it +// ruins the purpose of categories to only ADD functionality. Subclass instead to override methods. + +// Here is a simple Car base class. +@interface Car : NSObject + +@property NSString *make; +@property NSString *color; + +- (void)turnOn; +- (void)accelerate; + +@end + +// And the simple Car base class implementation: +#import "Car.h" + +@implementation Car + +@synthesize make = _make; +@synthesize color = _color; + +- (void)turnOn { + NSLog(@"Car is on."); +} +- (void)accelerate { + NSLog(@"Accelerating."); +} + +@end + +// Now, if we wanted to create a Truck object, we would instead create a subclass of Car as it would +// be changing the functionality of the Car to behave like a truck. But lets say we want to just add +// functionality to this existing Car. A good example would be to clean the car. So we would create +// a category to add these cleaning methods: +// @interface filename: Car+Clean.h (BaseClassName+CategoryName.h) +#import "Car.h" // Make sure to import base class to extend. + +@interface Car (Clean) // The category name is inside () following the name of the base class. + +- (void)washWindows; // Names of the new methods we are adding to our Car object. +- (void)wax; + +@end + +// @implementation filename: Car+Clean.m (BaseClassName+CategoryName.m) +#import "Car+Clean.h" // Import the Clean category's @interface file. + +@implementation Car (Clean) + +- (void)washWindows { + NSLog(@"Windows washed."); +} +- (void)wax { + NSLog(@"Waxed."); +} + +@end + +// Any Car object instance has the ability to use a category. All they need to do is import it: +#import "Car+Clean.h" // Import as many different categories as you want to use. +#import "Car.h" // Also need to import base class to use it's original functionality. + +int main (int argc, const char * argv[]) { + @autoreleasepool { + Car *mustang = [[Car alloc] init]; + mustang.color = @"Red"; + mustang.make = @"Ford"; + + [mustang turnOn]; // Use methods from base Car class. + [mustang washWindows]; // Use methods from Car's Clean category. + } + return 0; +} + +// Objective-C does not have protected method declarations but you can simulate them. +// Create a category containing all of the protected methods, then import it ONLY into the +// @implementation file of a class belonging to the Car class: +@interface Car (Protected) // Naming category 'Protected' to remember methods are protected. + +- (void)lockCar; // Methods listed here may only be created by Car objects. + +@end +//To use protected methods, import the category, then implement the methods: +#import "Car+Protected.h" // Remember, import in the @implementation file only. + +@implementation Car + +- (void)lockCar { + NSLog(@"Car locked."); // Instances of Car can't use lockCar because it's not in the @interface. +} + +@end + +/////////////////////////////////////// +// Extensions +/////////////////////////////////////// +// Extensions allow you to override public access property attributes and methods of an @interface. +// @interface filename: Shape.h +@interface Shape : NSObject // Base Shape class extension overrides below. + +@property (readonly) NSNumber *numOfSides; + +- (int)getNumOfSides; + +@end +// You can override numOfSides variable or getNumOfSides method to edit them with an extension: +// @implementation filename: Shape.m +#import "Shape.h" +// Extensions live in the same file as the class @implementation. +@interface Shape () // () after base class name declares an extension. + +@property (copy) NSNumber *numOfSides; // Make numOfSides copy instead of readonly. +-(NSNumber)getNumOfSides; // Make getNumOfSides return a NSNumber instead of an int. +-(void)privateMethod; // You can also create new private methods inside of extensions. + +@end +// The main @implementation: +@implementation Shape + +@synthesize numOfSides = _numOfSides; + +-(NSNumber)getNumOfSides { // All statements inside of extension must be in the @implementation. + return _numOfSides; +} +-(void)privateMethod { + NSLog(@"Private method created by extension. Shape instances cannot call me."); +} + +@end + +/////////////////////////////////////// +// Protocols +/////////////////////////////////////// +// A protocol declares methods that can be implemented by any class. +// Protocols are not classes themselves. They simply define an interface +// that other objects are responsible for implementing. +// @protocol filename: "CarUtilities.h" +@protocol CarUtilities <NSObject> // <NSObject> => Name of another protocol this protocol includes. + @property BOOL engineOn; // Adopting class must @synthesize all defined @properties and + - (void)turnOnEngine; // all defined methods. +@end +// Below is an example class implementing the protocol. +#import "CarUtilities.h" // Import the @protocol file. + +@interface Car : NSObject <CarUtilities> // Name of protocol goes inside <> + // You don't need the @property or method names here for CarUtilities. Only @implementation does. +- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // You can use protocols as data too. +@end +// The @implementation needs to implement the @properties and methods for the protocol. +@implementation Car : NSObject <CarUtilities> + +@synthesize engineOn = _engineOn; // Create a @synthesize statement for the engineOn @property. + +- (void)turnOnEngine { // Implement turnOnEngine however you would like. Protocols do not define + _engineOn = YES; // how you implement a method, it just requires that you do implement it. +} +// You may use a protocol as data as you know what methods and variables it has implemented. +- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind { + [objectOfSomeKind engineOn]; // You have access to object variables + [objectOfSomeKind turnOnEngine]; // and the methods inside. + [objectOfSomeKind engineOn]; // May or may not be YES. Class implements it however it wants. +} + +@end +// Instances of Car now have access to the protocol. +Car *carInstance = [[Car alloc] init]; +[carInstance setEngineOn:NO]; +[carInstance turnOnEngine]; +if ([carInstance engineOn]) { + NSLog(@"Car engine is on."); // prints => "Car engine is on." +} +// Make sure to check if an object of type 'id' implements a protocol before calling protocol methods: +if ([myClass conformsToProtocol:@protocol(CarUtilities)]) { + NSLog(@"This does not run as the MyClass class does not implement the CarUtilities protocol."); +} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) { + NSLog(@"This does run as the Car class implements the CarUtilities protocol."); +} +// Categories may implement protocols as well: @interface Car (CarCategory) <CarUtilities> +// You may implement many protocols: @interface Car : NSObject <CarUtilities, CarCleaning> +// NOTE: If two or more protocols rely on each other, make sure to forward-declare them: +#import "Brother.h" + +@protocol Brother; // Forward-declare statement. Without it, compiler would through error. + +@protocol Sister <NSObject> + +- (void)beNiceToBrother:(id <Brother>)brother; + +@end + +// See the problem is that Sister relies on Brother, and Brother relies on Sister. +#import "Sister.h" + +@protocol Sister; // These lines stop the recursion, resolving the issue. + +@protocol Brother <NSObject> + +- (void)beNiceToSister:(id <Sister>)sister; + +@end + + +/////////////////////////////////////// +// Blocks +/////////////////////////////////////// +// Blocks are statements of code, just like a function, that are able to be used as data. +// Below is a simple block with an integer argument that returns the argument plus 4. +int (^addUp)(int n); // Declare a variable to store the block. +void (^noParameterBlockVar)(void); // Example variable declaration of block with no arguments. +// Blocks have access to variables in the same scope. But the variables are readonly and the +// value passed to the block is the value of the variable when the block is created. +int outsideVar = 17; // If we edit outsideVar after declaring addUp, outsideVar is STILL 17. +__block long mutableVar = 3; // __block makes variables writable to blocks, unlike outsideVar. +addUp = ^(int n) { // Remove (int n) to have a block that doesn't take in any parameters. + NSLog(@"You may have as many lines in a block as you would like."); + NSSet *blockSet; // Also, you can declare local variables. + mutableVar = 32; // Assigning new value to __block variable. + return n + outsideVar; // Return statements are optional. +} +int addUp = add(10 + 16); // Calls block code with arguments. +// Blocks are often used as arguments to functions to be called later, or for callbacks. +@implementation BlockExample : NSObject + + - (void)runBlock:(void (^)(NSString))block { + NSLog(@"Block argument returns nothing and takes in a NSString object."); + block(@"Argument given to block to execute."); // Calling block. + } + + @end + + +/////////////////////////////////////// +// Memory Management +/////////////////////////////////////// +/* +For each object used in an application, memory must be allocated for that object. When the application +is done using that object, memory must be deallocated to ensure application efficiency. +Objective-C does not use garbage collection and instead uses reference counting. As long as +there is at least one reference to an object (also called "owning" an object), then the object +will be available to use (known as "ownership"). + +When an instance owns an object, its reference counter is increments by one. When the +object is released, the reference counter decrements by one. When reference count is zero, +the object is removed from memory. + +With all object interactions, follow the pattern of: +(1) create the object, (2) use the object, (3) then free the object from memory. +*/ + +MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object +[classVar release]; // Decrements classVar's reference count +// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object +MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner +[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object + +// @property can use 'retain' and 'assign' as well for small convenient definitions +@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference) +@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference) + +// Automatic Reference Counting (ARC) +// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC). +// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, +// you must not use retain, relase, or autorelease +MyClass *arcMyClass = [[MyClass alloc] init]; +// ... code using arcMyClass +// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, +// there is no need. It will insert this release statement for you + +// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong' +@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count +// is set to zero, weakVar will automatically receive value of nil to avoid application crashing +@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use + +// For regular variables (not @property declared variables), use the following: +__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope +__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil +__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released + +``` +## Further Reading + +[Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C) + +[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/ocaml.html.markdown b/ocaml.html.markdown new file mode 100644 index 00000000..02435e4d --- /dev/null +++ b/ocaml.html.markdown @@ -0,0 +1,377 @@ +--- +language: OCaml +contributors: + - ["Daniil Baturin", "http://baturin.org/"] +--- + +OCaml is a strictly evaluated functional language with some imperative +features. + +Along with StandardML and its dialects it belongs to ML language family. +F# is also heavily influenced by OCaml. + +Just like StandardML, OCaml features both an interpreter, that can be +used interactively, and a compiler. +The interpreter binary is normally called "ocaml" and the compiler is "ocamlopt". +There is also a bytecode compiler, "ocamlc", but there are few reasons to use it. + +It is strongly and statically typed, but instead of using manually written +type annotations, it infers types of expressions using Hindley-Milner algorithm. +It makes type annotations unnecessary in most cases, but can be a major +source of confusion for beginners. + +When you are in the top level loop, OCaml will print the inferred type +after you enter an expression. + +``` +# let inc x = x + 1 ;; +val inc : int -> int = <fun> +# let a = 99 ;; +val a : int = 99 +``` + +For a source file you can use "ocamlc -i /path/to/file.ml" command +to print all names and type signatures. + +``` +$ cat sigtest.ml +let inc x = x + 1 +let add x y = x + y + +let a = 1 + +$ ocamlc -i ./sigtest.ml +val inc : int -> int +val add : int -> int -> int +val a : int +``` + +Note that type signatures of functions of multiple arguments are +written in curried form. A function that takes multiple arguments can be +represented as a composition of functions that take only one argument. +The "f(x,y) = x + y" function from the example above applied to +arguments 2 and 3 is equivalent to the "f0(y) = 2 + y" function applied to 3. +Hence the "int -> int -> int" signature. + + +```ocaml +(*** Comments ***) + +(* Comments are enclosed in (* and *). It's fine to nest comments. *) + +(* There are no single-line comments. *) + + +(*** Variables and functions ***) + +(* Expressions can be separated by a double semicolon symbol, ";;". + In many cases it's redundant, but in this tutorial we use it after + every expression for easy pasting into the interpreter shell. + Unnecessary use of expression separators in source code files + is often considered to be a bad style. *) + +(* Variable and function declarations use "let" keyword. *) +let x = 10 ;; + +(* OCaml allows single quote characters in identifiers. + Single quote doesn't have a special meaning in this case, it's often used + in cases when in other languages one would use names like "foo_tmp". *) +let foo = 1 ;; +let foo' = foo * 2 ;; + +(* Since OCaml compiler infers types automatically, you normally don't need to + specify argument types explicitly. However, you can do it if + you want or need to. *) +let inc_int (x: int) : int = x + 1 ;; + +(* One of the cases when explicit type annotations may be needed is + resolving ambiguity between two record types that have fields with + the same name. The alternative is to encapsulate those types in + modules, but both topics are a bit out of scope of this + tutorial. *) + +(* You need to mark recursive function definitions as such with "rec" keyword. *) +let rec factorial n = + if n = 0 then 1 + else n * factorial (n-1) +;; + +(* Function application usually doesn't need parentheses around arguments *) +let fact_5 = factorial 5 ;; + +(* ...unless the argument is an expression. *) +let fact_4 = factorial (5-1) ;; +let sqr2 = sqr (-2) ;; + +(* Every function must have at least one argument. + Since some funcions naturally don't take any arguments, there's + "unit" type for it that has the only one value written as "()" *) +let print_hello () = print_endline "hello world" ;; + +(* Note that you must specify "()" as argument when calling it. *) +print_hello () ;; + +(* Calling a function with insufficient number of arguments + does not cause an error, it produces a new function. *) +let make_inc x y = x + y ;; (* make_inc is int -> int -> int *) +let inc_2 = make_inc 2 ;; (* inc_2 is int -> int *) +inc_2 3 ;; (* Evaluates to 5 *) + +(* You can use multiple expressions in function body. + The last expression becomes the return value. All other + expressions must be of the "unit" type. + This is useful when writing in imperative style, the simplest + form of it is inserting a debug print. *) +let print_and_return x = + print_endline (string_of_int x); + x +;; + +(* Since OCaml is a functional language, it lacks "procedures". + Every function must return something. So functions that + do not really return anything and are called solely for their + side effects, like print_endline, return value of "unit" type. *) + + +(* Definitions can be chained with "let ... in" construct. + This is roughly the same to assigning values to multiple + variables before using them in expressions in imperative + languages. *) +let x = 10 in +let y = 20 in +x + y ;; + +(* Alternatively you can use "let ... and ... in" construct. + This is especially useful for mutually recursive functions, + with ordinary "let .. in" the compiler will complain about + unbound values. *) +let rec + is_even = function + | 0 -> true + | n -> is_odd (n-1) +and + is_odd = function + | 0 -> false + | n -> is_even (n-1) +;; + +(* Anonymous functions use the following syntax: *) +let my_lambda = fun x -> x * x ;; + +(*** Operators ***) + +(* There is little distintion between operators and functions. + Every operator can be called as a function. *) + +(+) 3 4 (* Same as 3 + 4 *) + +(* There's a number of built-in operators. One unusual feature is + that OCaml doesn't just refrain from any implicit conversions + between integers and floats, it also uses different operators + for floats. *) +12 + 3 ;; (* Integer addition. *) +12.0 +. 3.0 ;; (* Floating point addition. *) + +12 / 3 ;; (* Integer division. *) +12.0 /. 3.0 ;; (* Floating point division. *) +5 mod 2 ;; (* Remainder. *) + +(* Unary minus is a notable exception, it's polymorphic. + However, it also has "pure" integer and float forms. *) +- 3 ;; (* Polymorphic, integer *) +- 4.5 ;; (* Polymorphic, float *) +~- 3 (* Integer only *) +~- 3.4 (* Type error *) +~-. 3.4 (* Float only *) + +(* You can define your own operators or redefine existing ones. + Unlike SML or Haskell, only selected symbols can be used + for operator names and first symbol defines associativity + and precedence rules. *) +let (+) a b = a - b ;; (* Surprise maintenance programmers. *) + +(* More useful: a reciprocal operator for floats. + Unary operators must start with "~". *) +let (~/) x = 1.0 /. x ;; +~/4.0 (* = 0.25 *) + + +(*** Built-in datastructures ***) + +(* Lists are enclosed in square brackets, items are separated by + semicolons. *) +let my_list = [1; 2; 3] ;; + +(* Tuples are (optionally) enclosed in parentheses, items are separated + by commas. *) +let first_tuple = 3, 4 ;; (* Has type "int * int". *) +let second_tuple = (4, 5) ;; + +(* Corollary: if you try to separate list items by commas, you get a list + with a tuple inside, probably not what you want. *) +let bad_list = [1, 2] ;; (* Becomes [(1, 2)] *) + +(* You can access individual list items with the List.nth function. *) +List.nth my_list 1 ;; + +(* There are higher-order functions for lists such as map and filter. *) +List.map (fun x -> x * 2) [1; 2; 3] ;; +List.filter (fun x -> if x mod 2 = 0 then true else false) [1; 2; 3; 4] ;; + +(* You can add an item to the beginning of a list with the "::" constructor + often referred to as "cons". *) +1 :: [2; 3] ;; (* Gives [1; 2; 3] *) + +(* Arrays are enclosed in [| |] *) +let my_array = [| 1; 2; 3 |] ;; + +(* You can access array items like this: *) +my_array.(0) ;; + + +(*** Strings and characters ***) + +(* Use double quotes for string literals. *) +let my_str = "Hello world" ;; + +(* Use single quotes for character literals. *) +let my_char = 'a' ;; + +(* Single and double quotes are not interchangeable. *) +let bad_str = 'syntax error' ;; (* Syntax error. *) + +(* This will give you a single character string, not a character. *) +let single_char_str = "w" ;; + +(* Strings can be concatenated with the "^" operator. *) +let some_str = "hello" ^ "world" ;; + +(* Strings are not arrays of characters. + You can't mix characters and strings in expressions. + You can convert a character to a string with "String.make 1 my_char". + There are more convenient functions for this purpose in additional + libraries such as Core.Std that may not be installed and/or loaded + by default. *) +let ocaml = (String.make 1 'O') ^ "Caml" ;; + +(* There is a printf function. *) +Printf.printf "%d %s" 99 "bottles of beer" ;; + +(* Unformatted read and write functions are there too. *) +print_string "hello world\n" ;; +print_endline "hello world" ;; +let line = read_line () ;; + + +(*** User-defined data types ***) + +(* You can define types with the "type some_type =" construct. Like in this + useless type alias: *) +type my_int = int ;; + +(* More interesting types include so called type constructors. + Constructors must start with a capital letter. *) +type ml = OCaml | StandardML ;; +let lang = OCaml ;; (* Has type "ml". *) + +(* Type constructors don't need to be empty. *) +type my_number = PlusInfinity | MinusInfinity | Real of float ;; +let r0 = Real (-3.4) ;; (* Has type "my_number". *) + +(* Can be used to implement polymorphic arithmetics. *) +type number = Int of int | Float of float ;; + +(* Point on a plane, essentially a type-constrained tuple *) +type point2d = Point of float * float ;; +let my_point = Point (2.0, 3.0) ;; + +(* Types can be parameterized, like in this type for "list of lists + of anything". 'a can be substituted with any type. *) +type 'a list_of_lists = 'a list list ;; +type int_list_list = int list_of_lists ;; + +(* Types can also be recursive. Like in this type analogous to + built-in list of integers. *) +type my_int_list = EmptyList | IntList of int * my_int_list ;; +let l = IntList (1, EmptyList) ;; + + +(*** Pattern matching ***) + +(* Pattern matching is somewhat similar to switch statement in imperative + languages, but offers a lot more expressive power. + + Even though it may look complicated, it really boils down to matching + an argument against an exact value, a predicate, or a type constructor. + The type system is what makes it so powerful. *) + +(** Matching exact values. **) + +let is_zero x = + match x with + | 0 -> true + | _ -> false (* The "_" pattern means "anything else". *) +;; + +(* Alternatively, you can use the "function" keyword. *) +let is_one = function +| 1 -> true +| _ -> false +;; + +(* Matching predicates, aka "guarded pattern matching". *) +let abs x = + match x with + | x when x < 0 -> -x + | _ -> x +;; + +abs 5 ;; (* 5 *) +abs (-5) (* 5 again *) + +(** Matching type constructors **) + +type animal = Dog of string | Cat of string ;; + +let say x = + match x with + | Dog x -> x ^ " says woof" + | Cat x -> x ^ " says meow" +;; + +say (Cat "Fluffy") ;; (* "Fluffy says meow". *) + +(** Traversing datastructures with pattern matching **) + +(* Recursive types can be traversed with pattern matching easily. + Let's see how we can traverse a datastructure of the built-in list type. + Even though the built-in cons ("::") looks like an infix operator, + it's actually a type constructor and can be matched like any other. *) +let rec sum_list l = + match l with + | [] -> 0 + | head :: tail -> head + (sum_list tail) +;; + +sum_list [1; 2; 3] ;; (* Evaluates to 6 *) + +(* Built-in syntax for cons obscures the structure a bit, so we'll make + our own list for demonstration. *) + +type int_list = Nil | Cons of int * int_list ;; +let rec sum_int_list l = + match l with + | Nil -> 0 + | Cons (head, tail) -> head + (sum_int_list tail) +;; + +let t = Cons (1, Cons (2, Cons (3, Nil))) ;; +sum_int_list t ;; + +``` + +## Further reading + +* Visit the official website to get the compiler and read the docs: <http://ocaml.org/> +* Try interactive tutorials and a web-based interpreter by OCaml Pro: <http://try.ocamlpro.com/> +* Read "OCaml for the skeptical" course: <http://www2.lib.uchicago.edu/keith/ocaml-class/home.html> diff --git a/paren.html.markdown b/paren.html.markdown new file mode 100644 index 00000000..cde14853 --- /dev/null +++ b/paren.html.markdown @@ -0,0 +1,193 @@ +--- + +language: Paren +filename: learnparen.paren +contributors: + - ["KIM Taegyoon", "https://github.com/kimtg"] +--- + +[Paren](https://bitbucket.org/ktg/paren) is a dialect of Lisp. It is designed to be an embedded language. + +Some examples are from <http://learnxinyminutes.com/docs/racket/>. + +```scheme +;;; Comments +# comments + +;; Single line comments start with a semicolon or a sharp sign + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Primitive Datatypes and Operators +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Numbers +123 ; int +3.14 ; double +6.02e+23 ; double +(int 3.14) ; => 3 : int +(double 123) ; => 123 : double + +;; Function application is written (f x y z ...) +;; where f is a function and x, y, z, ... are operands +;; If you want to create a literal list of data, use (quote) to stop it from +;; being evaluated +(quote (+ 1 2)) ; => (+ 1 2) +;; Now, some arithmetic operations +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(^ 2 3) ; => 8 +(/ 5 2) ; => 2 +(% 5 2) ; => 1 +(/ 5.0 2) ; => 2.5 + +;;; Booleans +true ; for true +false ; for false +(! true) ; => false +(&& true false (prn "doesn't get here")) ; => false +(|| false true (prn "doesn't get here")) ; => true + +;;; Characters are ints. +(char-at "A" 0) ; => 65 +(chr 65) ; => "A" + +;;; Strings are fixed-length array of characters. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; backslash is an escaping character +"Foo\tbar\r\n" ; includes C escapes: \t \r \n + +;; Strings can be added too! +(strcat "Hello " "world!") ; => "Hello world!" + +;; A string can be treated like a list of characters +(char-at "Apple" 0) ; => 65 + +;; Printing is pretty easy +(pr "I'm" "Paren. ") (prn "Nice to meet you!") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variables +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; You can create or set a variable using (set) +;; a variable name can use any character except: ();#" +(set some-var 5) ; => 5 +some-var ; => 5 + +;; Accessing a previously unassigned variable is an exception +; x ; => Unknown variable: x : nil + +;; Local binding: Use lambda calculus! `a' and `b' are bound to `1' and `2' only within the (fn ...) +((fn (a b) (+ a b)) 1 2) ; => 3 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Collections +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Lists + +;; Lists are vector-like data structures. (Random access is O(1).) +(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3) +;; `list' is a convenience variadic constructor for lists +(list 1 2 3) ; => (1 2 3) +;; and a quote can also be used for a literal list value +(quote (+ 1 2)) ; => (+ 1 2) + +;; Can still use `cons' to add an item to the beginning of a list +(cons 0 (list 1 2 3)) ; => (0 1 2 3) + +;; Lists are a very basic type, so there is a *lot* of functionality for +;; them, a few examples: +(map inc (list 1 2 3)) ; => (2 3 4) +(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4) +(length (list 1 2 3 4)) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Functions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `fn' to create functions. +;; A function always returns the value of its last expression +(fn () "Hello World") ; => (fn () Hello World) : fn + +;; Use parentheses to call all functions, including a lambda expression +((fn () "Hello World")) ; => "Hello World" + +;; Assign a function to a var +(set hello-world (fn () "Hello World")) +(hello-world) ; => "Hello World" + +;; You can shorten this using the function definition syntatcic sugae: +(defn hello-world2 () "Hello World") + +;; The () in the above is the list of arguments for the function +(set hello + (fn (name) + (strcat "Hello " name))) +(hello "Steve") ; => "Hello Steve" + +;; ... or equivalently, using a sugared definition: +(defn hello2 (name) + (strcat "Hello " name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Equality +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; for numbers use `==' +(== 3 3.0) ; => true +(== 2 1) ; => false + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Control Flow +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Conditionals + +(if true ; test expression + "this is true" ; then expression + "this is false") ; else expression +; => "this is true" + +;;; Loops + +;; for loop is for number +;; (for SYMBOL START END STEP EXPR ..) +(for i 0 10 2 (pr i "")) ; => prints 0 2 4 6 8 10 +(for i 0.0 10 2.5 (pr i "")) ; => prints 0 2.5 5 7.5 10 + +;; while loop +((fn (i) + (while (< i 10) + (pr i) + (++ i))) 0) ; => prints 0123456789 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutation +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `set' to assign a new value to a variable or a place +(set n 5) ; => 5 +(set n (inc n)) ; => 6 +n ; => 6 +(set a (list 1 2)) ; => (1 2) +(set (nth 0 a) 3) ; => 3 +a ; => (3 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Macros let you extend the syntax of the language. +;; Paren macros are easy. +;; In fact, (defn) is a macro. +(defmacro setfn (name ...) (set name (fn ...))) +(defmacro defn (name ...) (def name (fn ...))) + +;; Let's add an infix notation +(defmacro infix (a op ...) (op a ...)) +(infix 1 + 2 (infix 3 * 4)) ; => 15 + +;; Macros are not hygienic, you can clobber existing variables! +;; They are code transformations. +``` diff --git a/perl.html.markdown b/perl.html.markdown new file mode 100644 index 00000000..4e172406 --- /dev/null +++ b/perl.html.markdown @@ -0,0 +1,165 @@ +--- +name: perl +category: language +language: perl +filename: learnperl.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] +--- + +Perl 5 is a highly capable, feature-rich programming language with over 25 years of development. + +Perl 5 runs on over 100 platforms from portables to mainframes and is suitable for both rapid prototyping and large scale development projects. + +```perl +# Single line comments start with a number sign. + + +#### Perl variable types + +# Variables begin with a sigil, which is a symbol showing the type. +# A valid variable name starts with a letter or underscore, +# followed by any number of letters, numbers, or underscores. + +### Perl has three main variable types: $scalar, @array, and %hash. + +## Scalars +# A scalar represents a single value: +my $animal = "camel"; +my $answer = 42; + +# Scalar values can be strings, integers or floating point numbers, and +# Perl will automatically convert between them as required. + +## Arrays +# An array represents a list of values: +my @animals = ("camel", "llama", "owl"); +my @numbers = (23, 42, 69); +my @mixed = ("camel", 42, 1.23); + + + +## Hashes +# A hash represents a set of key/value pairs: + +my %fruit_color = ("apple", "red", "banana", "yellow"); + +# You can use whitespace and the "=>" operator to lay them out more nicely: + +my %fruit_color = ( + apple => "red", + banana => "yellow", +); +# Scalars, arrays and hashes are documented more fully in perldata. +# (perldoc perldata). + +# More complex data types can be constructed using references, which allow you +# to build lists and hashes within lists and hashes. + +#### Conditional and looping constructs + +# Perl has most of the usual conditional and looping constructs. + +if ($var) { + ... +} elsif ($var eq 'bar') { + ... +} else { + ... +} + +unless (condition) { + ... +} +# This is provided as a more readable version of "if (!condition)" + +# the Perlish post-condition way +print "Yow!" if $zippy; +print "We have no bananas" unless $bananas; + +# while +while (condition) { + ... +} + + +# for loops and iteration +for (my $i = 0; $i < $max; $i++) { + print "index is $i"; +} + +for (my $i = 0; $i < @elements; $i++) { + print "Current element is " . $elements[$i]; +} + +for my $element (@elements) { + print $element; +} + +# implicitly + +for (@elements) { + print; +} + + +#### Regular expressions + +# Perl's regular expression support is both broad and deep, and is the subject +# of lengthy documentation in perlrequick, perlretut, and elsewhere. +# However, in short: + +# Simple matching +if (/foo/) { ... } # true if $_ contains "foo" +if ($a =~ /foo/) { ... } # true if $a contains "foo" + +# Simple substitution + +$a =~ s/foo/bar/; # replaces foo with bar in $a +$a =~ s/foo/bar/g; # replaces ALL INSTANCES of foo with bar in $a + + +#### Files and I/O + +# You can open a file for input or output using the "open()" function. + +open(my $in, "<", "input.txt") or die "Can't open input.txt: $!"; +open(my $out, ">", "output.txt") or die "Can't open output.txt: $!"; +open(my $log, ">>", "my.log") or die "Can't open my.log: $!"; + +# You can read from an open filehandle using the "<>" operator. In scalar +# context it reads a single line from the filehandle, and in list context it +# reads the whole file in, assigning each line to an element of the list: + +my $line = <$in>; +my @lines = <$in>; + +#### Writing subroutines + +# Writing subroutines is easy: + +sub logger { + my $logmessage = shift; + + open my $logfile, ">>", "my.log" or die "Could not open my.log: $!"; + + print $logfile $logmessage; +} + +# Now we can use the subroutine just as any other built-in function: + +logger("We have a logger subroutine!"); +``` + +#### Using Perl modules + +Perl modules provide a range of features to help you avoid reinventing the wheel, and can be downloaded from CPAN (http://www.cpan.org/). A number of popular modules are included with the Perl distribution itself. + +perlfaq contains questions and answers related to many common tasks, and often provides suggestions for good CPAN modules to use. + +#### Further Reading + + - [perl-tutorial](http://perl-tutorial.org/) + - [Learn at www.perl.com](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - and perl built-in : `perldoc perlintro` diff --git a/perl6.html.markdown b/perl6.html.markdown new file mode 100644 index 00000000..63c0830a --- /dev/null +++ b/perl6.html.markdown @@ -0,0 +1,1464 @@ +--- +name: perl6 +category: language +language: perl6 +filename: learnperl6.pl +contributors: + - ["Nami-Doc", "http://github.com/Nami-Doc"] +--- + +Perl 6 is a highly capable, feature-rich programming language made for at +least the next hundred years. + +The primary Perl 6 compiler is called [Rakudo](http://rakudo.org), which runs on +the JVM and [the MoarVM](http://moarvm.com) and +[prior to March 2015](http://pmthium.com/2015/02/suspending-rakudo-parrot/), +[the Parrot VM](http://parrot.org/). + +Meta-note : the triple pound signs are here to denote headlines, +double paragraphs, and single notes. + +`#=>` represents the output of a command. + +```perl +# Single line comment start with a pound + +#`( + Multiline comments use #` and a quoting construct. + (), [], {}, 「」, etc, will work. +) + +### Variables + +# In Perl 6, you declare a lexical variable using `my` +my $variable; +# Perl 6 has 4 kinds of variables: + +## * Scalars. They represent a single value. They start with a `$` + +my $str = 'String'; +# double quotes allow for interpolation (which we'll see later): +my $str2 = "String"; + +# variable names can contain but not end with simple quotes and dashes, +# and can contain (and end with) underscores : +# my $weird'variable-name_ = 5; # works ! + +my $bool = True; # `True` and `False` are Perl 6's boolean +my $inverse = !$bool; # You can invert a bool with the prefix `!` operator +my $forced-bool = so $str; # And you can use the prefix `so` operator + # which turns its operand into a Bool + +## * Lists. They represent multiple values. Their name start with `@`. + +my @array = 'a', 'b', 'c'; +# equivalent to : +my @letters = <a b c>; # array of words, delimited by space. + # Similar to perl5's qw, or Ruby's %w. +my @array = 1, 2, 3; + +say @array[2]; # Array indices start at 0 -- This is the third element + +say "Interpolate an array using [] : @array[]"; +#=> Interpolate an array using [] : 1 2 3 + +@array[0] = -1; # Assign a new value to an array index +@array[0, 1] = 5, 6; # Assign multiple values + +my @keys = 0, 2; +@array[@keys] = @letters; # Assign using an array +say @array; #=> a 6 b + +## * Hashes, or key-value Pairs. +# Hashes are actually arrays of Pairs +# (you can construct a Pair object using the syntax `Key => Value`), +# except they get "flattened" (hash context), removing duplicated keys. +my %hash = 1 => 2, + 3 => 4; +my %hash = autoquoted => "key", # keys get auto-quoted + "some other" => "value", # trailing commas are okay + ; +my %hash = <key1 value1 key2 value2>; # you can also create a hash + # from an even-numbered array +my %hash = key1 => 'value1', key2 => 'value2'; # same as this + +# You can also use the "colon pair" syntax: +# (especially handy for named parameters that you'll see later) +my %hash = :w(1), # equivalent to `w => 1` + # this is useful for the `True` shortcut: + :truey, # equivalent to `:truey(True)`, or `truey => True` + # and for the `False` one: + :!falsey, # equivalent to `:falsey(False)`, or `falsey => False` + ; + +say %hash{'key1'}; # You can use {} to get the value from a key +say %hash<key2>; # If it's a string, you can actually use <> + # (`{key1}` doesn't work, as Perl6 doesn't have barewords) + +## * Subs (subroutines, or functions in most other languages). +# Stored in variable, they use `&`. +sub say-hello { say "Hello, world" } + +sub say-hello-to(Str $name) { # You can provide the type of an argument + # and it'll be checked at compile-time. + + say "Hello, $name !"; +} + +## It can also have optional arguments: +sub with-optional($arg?) { # the "?" marks the argument optional + say "I might return `(Any)` if I don't have an argument passed, + or I'll return my argument"; + $arg; +} +with-optional; # returns Any +with-optional(); # returns Any +with-optional(1); # returns 1 + +## You can also give them a default value when they're not passed: +sub hello-to($name = "World") { + say "Hello, $name !"; +} +hello-to; #=> Hello, World ! +hello-to(); #=> Hello, World ! +hello-to('You'); #=> Hello, You ! + +## You can also, by using a syntax akin to the one of hashes (yay unified syntax !), +## pass *named* arguments to a `sub`. +# They're optional, and will default to "Any" (Perl's "null"-like value). +sub with-named($normal-arg, :$named) { + say $normal-arg + $named; +} +with-named(1, named => 6); #=> 7 +# There's one gotcha to be aware of, here: +# If you quote your key, Perl 6 won't be able to see it at compile time, +# and you'll have a single Pair object as a positional paramater, +# which means this fails: +with-named(1, 'named' => 6); + +with-named(2, :named(5)); #=> 7 + +# To make a named argument mandatory, you can use `?`'s inverse, `!` +sub with-mandatory-named(:$str!) { + say "$str !"; +} +with-mandatory-named(str => "My String"); #=> My String ! +with-mandatory-named; # run time error: "Required named parameter not passed" +with-mandatory-named(3); # run time error: "Too many positional parameters passed" + +## If a sub takes a named boolean argument ... +sub takes-a-bool($name, :$bool) { + say "$name takes $bool"; +} +# ... you can use the same "short boolean" hash syntax: +takes-a-bool('config', :bool); # config takes True +takes-a-bool('config', :!bool); # config takes False + +## You can also provide your named arguments with defaults: +sub named-def(:$def = 5) { + say $def; +} +named-def; #=> 5 +named-def(def => 15); #=> 15 + +# Since you can omit parenthesis to call a function with no arguments, +# you need "&" in the name to capture `say-hello`. +my &s = &say-hello; +my &other-s = sub { say "Anonymous function !" } + +# A sub can have a "slurpy" parameter, or "doesn't-matter-how-many" +sub as-many($head, *@rest) { # `*@` (slurpy) will basically "take everything else". + # Note: you can have parameters *before* (like here) + # a slurpy one, but not *after*. + say @rest.join(' / ') ~ " !"; +} +say as-many('Happy', 'Happy', 'Birthday'); #=> Happy / Birthday ! + # Note that the splat did not consume + # the parameter before. + +## You can call a function with an array using the +# "argument list flattening" operator `|` +# (it's not actually the only role of this operator, but it's one of them) +sub concat3($a, $b, $c) { + say "$a, $b, $c"; +} +concat3(|@array); #=> a, b, c + # `@array` got "flattened" as a part of the argument list + +### Containers +# In Perl 6, values are actually stored in "containers". +# The assignment operator asks the container on the left to store the value on +# its right. When passed around, containers are marked as immutable. +# Which means that, in a function, you'll get an error if you try to +# mutate one of your arguments. +# If you really need to, you can ask for a mutable container using `is rw`: +sub mutate($n is rw) { + $n++; + say "\$n is now $n !"; +} + +# If what you want is a copy instead, use `is copy`. + +# A sub itself returns a container, which means it can be marked as rw: +my $x = 42; +sub x-store() is rw { $x } +x-store() = 52; # in this case, the parentheses are mandatory + # (else Perl 6 thinks `x-store` is an identifier) +say $x; #=> 52 + + +### Control Flow Structures +## Conditionals + +# - `if` +# Before talking about `if`, we need to know which values are "Truthy" +# (represent True), and which are "Falsey" (or "Falsy") -- represent False. +# Only these values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or `Int`), +# and of course False itself. +# Every other value is Truthy. +if True { + say "It's true !"; +} + +unless False { + say "It's not false !"; +} + +# As you can see, you don't need parentheses around conditions. +# However, you do need the brackets around the "body" block: +# if (true) say; # This doesn't work ! + +# You can also use their postfix versions, with the keyword after: +say "Quite truthy" if True; + +# - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages) +my $a = $condition ?? $value-if-true !! $value-if-false; + +# - `given`-`when` looks like other languages `switch`, but much more +# powerful thanks to smart matching and thanks to Perl 6's "topic variable", $_. +# +# This variable contains the default argument of a block, +# a loop's current iteration (unless explicitly named), etc. +# +# `given` simply puts its argument into `$_` (like a block would do), +# and `when` compares it using the "smart matching" (`~~`) operator. +# +# Since other Perl 6 constructs use this variable (as said before, like `for`, +# blocks, etc), this means the powerful `when` is not only applicable along with +# a `given`, but instead anywhere a `$_` exists. +given "foo bar" { + say $_; #=> foo bar + when /foo/ { # Don't worry about smart matching yet – just know `when` uses it. + # This is equivalent to `if $_ ~~ /foo/`. + say "Yay !"; + } + when $_.chars > 50 { # smart matching anything with True (`$a ~~ True`) is True, + # so you can also put "normal" conditionals. + # This when is equivalent to this `if`: + # if $_ ~~ ($_.chars > 50) {...} + # Which means: + # if $_.chars > 50 {...} + say "Quite a long string !"; + } + default { # same as `when *` (using the Whatever Star) + say "Something else" + } +} + +## Looping constructs + +# - `loop` is an infinite loop if you don't pass it arguments, +# but can also be a C-style `for` loop: +loop { + say "This is an infinite loop !"; + last; # last breaks out of the loop, like the `break` keyword in other languages +} + +loop (my $i = 0; $i < 5; $i++) { + next if $i == 3; # `next` skips to the next iteration, like `continue` + # in other languages. Note that you can also use postfix + # conditionals, loops, etc. + say "This is a C-style for loop !"; +} + +# - `for` - Passes through an array +for @array -> $variable { + say "I've got $variable !"; +} + +# As we saw with given, for's default "current iteration" variable is `$_`. +# That means you can use `when` in a `for` just like you were in a `given`. +for @array { + say "I've got $_"; + + .say; # This is also allowed. + # A dot call with no "topic" (receiver) is sent to `$_` by default + $_.say; # the above and this are equivalent. +} + +for @array { + # You can... + next if $_ == 3; # Skip to the next iteration (`continue` in C-like languages). + redo if $_ == 4; # Re-do the iteration, keeping the same topic variable (`$_`). + last if $_ == 5; # Or break out of a loop (like `break` in C-like languages). +} + +# The "pointy block" syntax isn't specific to for. +# It's just a way to express a block in Perl6. +if long-computation() -> $result { + say "The result is $result"; +} + +### Operators + +## Since Perl languages are very much operator-based languages, +## Perl 6 operators are actually just funny-looking subroutines, in syntactic +## categories, like infix:<+> (addition) or prefix:<!> (bool not). + +## The categories are: +# - "prefix": before (like `!` in `!True`). +# - "postfix": after (like `++` in `$a++`). +# - "infix": in between (like `*` in `4 * 3`). +# - "circumfix": around (like `[`-`]` in `[1, 2]`). +# - "post-circumfix": around, after another term (like `{`-`}` in `%hash{'key'}`) + +## The associativity and precedence list are explained below. + +# Alright, you're set to go ! + +## * Equality Checking + +# - `==` is numeric comparison +3 == 4; # False +3 != 4; # True + +# - `eq` is string comparison +'a' eq 'b'; +'a' ne 'b'; # not equal +'a' !eq 'b'; # same as above + +# - `eqv` is canonical equivalence (or "deep equality") +(1, 2) eqv (1, 3); + +# - `~~` is smart matching +# For a complete list of combinations, use this table: +# http://perlcabal.org/syn/S03.html#Smart_matching +'a' ~~ /a/; # true if matches regexp +'key' ~~ %hash; # true if key exists in hash +$arg ~~ &bool-returning-function; # `True` if the function, passed `$arg` + # as an argument, returns `True`. +1 ~~ Int; # "has type" (check superclasses and roles) +1 ~~ True; # smart-matching against a boolean always returns that boolean + # (and will warn). + +# You also, of course, have `<`, `<=`, `>`, `>=`. +# Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`. +3 > 4; + +## * Range constructors +3 .. 7; # 3 to 7, both included +# `^` on either side them exclusive on that side : +3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`) +# This also works as a shortcut for `0..^N`: +^10; # means 0..^10 + +# This also allows us to demonstrate that Perl 6 has lazy/infinite arrays, +# using the Whatever Star: +my @array = 1..*; # 1 to Infinite ! `1..Inf` is the same. +say @array[^10]; # you can pass arrays as subscripts and it'll return + # an array of results. This will print + # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory !) +# Note : when reading an infinite list, Perl 6 will "reify" the elements +# it needs, then keep them in memory. They won't be calculated more than once. +# It also will never calculate more elements that are needed. + +# An array subscript can also be a closure. +# It'll be called with the length as the argument +say join(' ', @array[15..*]); #=> 15 16 17 18 19 +# which is equivalent to: +say join(' ', @array[-> $n { 15..$n }]); + +# You can use that in most places you'd expect, even assigning to an array +my @numbers = ^20; +my @seq = 3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99 +@numbers[5..*] = 3, 9 ... *; # even though the sequence is infinite, + # only the 15 needed values will be calculated. +say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87 + # (only 20 values) + +## * And, Or +3 && 4; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`. +0 || False; # False. Calls `.Bool` on `0` + +## * Short-circuit (and tight) versions of the above +$a && $b && $c; # Returns the first argument that evaluates to False, + # or the last argument. +$a || $b; + +# And because you're going to want them, +# you also have compound assignment operators: +$a *= 2; # multiply and assignment +$b %%= 5; # divisible by and assignment +@array .= sort; # calls the `sort` method and assigns the result back + +### More on subs ! +# As we said before, Perl 6 has *really* powerful subs. We're going to see +# a few more key concepts that make them better than in any other language :-). + +## Unpacking ! +# It's the ability to "extract" arrays and keys (AKA "destructuring"). +# It'll work in `my`s and in parameter lists. +my ($a, $b) = 1, 2; +say $a; #=> 1 +my ($, $, $c) = 1, 2, 3; # keep the non-interesting anonymous +say $c; #=> 3 + +my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs" +my (*@small) = 1; + +sub foo(@array [$fst, $snd]) { + say "My first is $fst, my second is $snd ! All in all, I'm @array[]."; + # (^ remember the `[]` to interpolate the array) +} +foo(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3 + + +# If you're not using the array itself, you can also keep it anonymous, +# much like a scalar: +sub first-of-array(@ [$fst]) { $fst } +first-of-array(@small); #=> 1 +first-of-array(@tail); # Throws an error "Too many positional parameters passed" + # (which means the array is too big). + +# You can also use a slurp ... +sub slurp-in-array(@ [$fst, *@rest]) { # You could keep `*@rest` anonymous + say $fst + @rest.elems; # `.elems` returns a list's length. + # Here, `@rest` is `(3,)`, since `$fst` holds the `2`. +} +slurp-in-array(@tail); #=> 3 + +# You could even extract on a slurpy (but it's pretty useless ;-).) +sub fst(*@ [$fst]) { # or simply : `sub fst($fst) { ... }` + say $fst; +} +fst(1); #=> 1 +fst(1, 2); # errors with "Too many positional parameters passed" + +# You can also destructure hashes (and classes, which you'll learn about later !) +# The syntax is basically `%hash-name (:key($variable-to-store-value-in))`. +# The hash can stay anonymous if you only need the values you extracted. +sub key-of(% (:value($val), :qua($qua))) { + say "Got val $val, $qua times."; +} + +# Then call it with a hash: (you need to keep the brackets for it to be a hash) +key-of({value => 'foo', qua => 1}); +#key-of(%hash); # the same (for an equivalent `%hash`) + +## The last expression of a sub is returned automatically +# (though you may use the `return` keyword, of course): +sub next-index($n) { + $n + 1; +} +my $new-n = next-index(3); # $new-n is now 4 + +# This is true for everything, except for the looping constructs +# (due to performance reasons): there's reason to build a list +# if we're just going to discard all the results. +# If you still want to build one, you can use the `do` statement prefix: +# (or the `gather` prefix, which we'll see later) +sub list-of($n) { + do for ^$n { # note the use of the range-to prefix operator `^` (`0..^N`) + $_ # current loop iteration + } +} +my @list3 = list-of(3); #=> (0, 1, 2) + +## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block") +my &lambda = -> $argument { "The argument passed to this lambda is $argument" } +# `-> {}` and `{}` are pretty much the same thing, except that the former can +# take arguments, and that the latter can be mistaken as a hash by the parser. + +# We can, for example, add 3 to each value of an array using map: +my @arrayplus3 = map({ $_ + 3 }, @array); # $_ is the implicit argument + +# A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`): +# A block doesn't have a "function context" (though it can have arguments), +# which means that if you return from it, +# you're going to return from the parent function. Compare: +sub is-in(@array, $elem) { + # this will `return` out of the `is-in` sub + # once the condition evaluated to True, the loop won't be run anymore + map({ return True if $_ == $elem }, @array); +} +sub truthy-array(@array) { + # this will produce an array of `True` and `False`: + # (you can also say `anon sub` for "anonymous subroutine") + map(sub ($i) { if $i { return True } else { return False } }, @array); + # ^ the `return` only returns from the anonymous `sub` +} + +# You can also use the "whatever star" to create an anonymous function +# (it'll stop at the furthest operator in the current expression) +my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }` +my @arrayplus3 = map(*+*+3, @array); # Same as `-> $a, $b { $a + $b + 3 }` + # also `sub ($a, $b) { $a + $b + 3 }` +say (*/2)(4); #=> 2 + # Immediatly execute the function Whatever created. +say ((*+3)/5)(5); #=> 1.6 + # works even in parens ! + +# But if you need to have more than one argument (`$_`) +# in a block (without wanting to resort to `-> {}`), +# you can also use the implicit argument syntax, `$^` : +map({ $^a + $^b + 3 }, @array); # equivalent to following: +map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`) + +# Note : those are sorted lexicographically. +# `{ $^b / $^a }` is like `-> $a, $b { $b / $a }` + +## About types... +# Perl6 is gradually typed. This means you can specify the type +# of your variables/arguments/return types, or you can omit them +# and they'll default to "Any". +# You obviously get access to a few base types, like Int and Str. +# The constructs for declaring types are "class", "role", +# which you'll see later. + +# For now, let us examinate "subset": +# a "subset" is a "sub-type" with additional checks. +# For example: "a very big integer is an Int that's greater than 500" +# You can specify the type you're subtyping (by default, Any), +# and add additional checks with the "where" keyword: +subset VeryBigInteger of Int where * > 500; + +## Multiple Dispatch +# Perl 6 can decide which variant of a `sub` to call based on the type of the +# arguments, or on arbitrary preconditions, like with a type or a `where`: + +# with types +multi sub sayit(Int $n) { # note the `multi` keyword here + say "Number: $n"; +} +multi sayit(Str $s) { # a multi is a `sub` by default + say "String: $s"; +} +sayit("foo"); # prints "String: foo" +sayit(True); # fails at *compile time* with + # "calling 'sayit' will never work with arguments of types ..." + +# with arbitrary precondition (remember subsets?): +multi is-big(Int $n where * > 50) { "Yes !" } # using a closure +multi is-big(Int $ where 10..50) { "Quite." } # Using smart-matching + # (could use a regexp, etc) +multi is-big(Int $) { "No" } + +subset Even of Int where * %% 2; + +multi odd-or-even(Even) { "Even" } # The main case using the type. + # We don't name the argument. +multi odd-or-even($) { "Odd" } # "else" + +# You can even dispatch based on a positional's argument presence ! +multi with-or-without-you(:$with!) { # You need make it mandatory to + # be able to dispatch against it. + say "I can live ! Actually, I can't."; +} +multi with-or-without-you { + say "Definitely can't live."; +} +# This is very, very useful for many purposes, like `MAIN` subs (covered later), +# and even the language itself is using it in several places. +# +# - `is`, for example, is actually a `multi sub` named `trait_mod:<is>`, +# and it works off that. +# - `is rw`, is simply a dispatch to a function with this signature: +# sub trait_mod:<is>(Routine $r, :$rw!) {} +# +# (commented because running this would be a terrible idea !) + + +### Scoping +# In Perl 6, contrarily to many scripting languages (like Python, Ruby, PHP), +# you are to declare your variables before using them. You know `my`. +# (there are other declarators, `our`, `state`, ..., which we'll see later). +# This is called "lexical scoping", where in inner blocks, +# you can access variables from outer blocks. +my $foo = 'Foo'; +sub foo { + my $bar = 'Bar'; + sub bar { + say "$foo $bar"; + } + &bar; # return the function +} +foo()(); #=> 'Foo Bar' + +# As you can see, `$foo` and `$bar` were captured. +# But if we were to try and use `$bar` outside of `foo`, +# the variable would be undefined (and you'd get a compile time error). + +# Perl 6 has another kind of scope : dynamic scope. +# They use the twigil (composed sigil) `*` to mark dynamically-scoped variables: +my $*a = 1; +# Dyamically-scoped variables depend on the current call stack, +# instead of the current block depth. +sub foo { + my $*foo = 1; + bar(); # call `bar` in-place +} +sub bar { + say $*foo; # `$*a` will be looked in the call stack, and find `foo`'s, + # even though the blocks aren't nested (they're call-nested). + #=> 1 +} + +### Object Model + +## Perl 6 has a quite comprehensive object model +# You declare a class with the keyword `class`, fields with `has`, +# methods with `method`. Every field to private, and is named `$!attr`, +# but you have `$.` to get a public (immutable) accessor along with it. +# (using `$.` is like using `$!` plus a `method` with the same name) + +# (Perl 6's object model ("SixModel") is very flexible, +# and allows you to dynamically add methods, change semantics, etc ... +# (this will not be covered here, and you should refer to the Synopsis). + +class A { + has $.field; # `$.field` is immutable. + # From inside the class, use `$!field` to modify it. + has $.other-field is rw; # You can obviously mark a public field `rw`. + has Int $!private-field = 10; + + method get-value { + $.field + $!private-field; + } + + method set-value($n) { + # $.field = $n; # As stated before, you can't use the `$.` immutable version. + $!field = $n; # This works, because `$!` is always mutable. + + $.other-field = 5; # This works, because `$.other-field` is `rw`. + } + + method !private-method { + say "This method is private to the class !"; + } +}; + +# Create a new instance of A with $.field set to 5 : +# Note: you can't set private-field from here (more later on). +my $a = A.new(field => 5); +$a.get-value; #=> 15 +#$a.field = 5; # This fails, because the `has $.field` is immutable +$a.other-field = 10; # This, however, works, because the public field + # is mutable (`rw`). + +## Perl 6 also has inheritance (along with multiple inheritance) +# (though considered a misfeature by many) + +class A { + has $.val; + + submethod not-inherited { + say "This method won't be available on B."; + say "This is most useful for BUILD, which we'll see later"; + } + + method bar { $.val * 5 } +} +class B is A { # inheritance uses `is` + method foo { + say $.val; + } + + method bar { $.val * 10 } # this shadows A's `bar` +} + +# When you use `my T $var`, `$var` starts off with `T` itself in it, +# so you can call `new` on it. +# (`.=` is just the dot-call and the assignment operator: +# `$a .= b` is the same as `$a = $a.b`) +# Also note that `BUILD` (the method called inside `new`) +# will set parent properties too, so you can pass `val => 5`. +my B $b .= new(val => 5); + +# $b.not-inherited; # This won't work, for reasons explained above +$b.foo; # prints 5 +$b.bar; #=> 50, since it calls B's `bar` + +## Roles are supported too (also called Mixins in other languages) +role PrintableVal { + has $!counter = 0; + method print { + say $.val; + } +} + +# you "import" a mixin (a "role") with "does": +class Item does PrintableVal { + has $.val; + + # When `does`-ed, a `role` literally "mixes in" the class: + # the methods and fields are put together, which means a class can access + # the private fields/methods of its roles (but not the inverse !): + method access { + say $!counter++; + } + + # However, this: + # method print {} + # is ONLY valid when `print` isn't a `multi` with the same dispatch. + # (this means a parent class can shadow a child class's `multi print() {}`, + # but it's an error if a role does) + + # NOTE: You can use a role as a class (with `is ROLE`). In this case, methods + # will be shadowed, since the compiler will consider `ROLE` to be a class. +} + +### Exceptions +# Exceptions are built on top of classes, in the package `X` (like `X::IO`). +# Unlike many other languages, in Perl 6, you put the `CATCH` block *within* the +# block to `try`. By default, a `try` has a `CATCH` block that catches +# any exception (`CATCH { default {} }`). +# You can redefine it using `when`s (and `default`) +# to handle the exceptions you want: +try { + open 'foo'; + CATCH { + when X::AdHoc { say "unable to open file !" } + # Any other exception will be re-raised, since we don't have a `default` + # Basically, if a `when` matches (or there's a `default`) marks the exception as + # "handled" so that it doesn't get re-thrown from the `CATCH`. + # You still can re-throw the exception (see below) by hand. + } +} + +# You can throw an exception using `die`: +die X::AdHoc.new(payload => 'Error !'); + +# You can access the last exception with `$!` (usually used in a `CATCH` block) + +# There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`, +# which is a kind of "unthrown exception". They're not thrown until you tried to look +# at their content, unless you call `.Bool`/`.defined` on them - then they're handled. +# (the `.handled` method is `rw`, so you can mark it as `False` back yourself) +# +# You can throw a `Failure` using `fail`. Note that if the pragma `use fatal` is on, +# `fail` will throw an exception (like `die`). +fail "foo"; # We're not trying to access the value, so no problem. +try { + fail "foo"; + CATCH { + default { say "It threw because we try to get the fail's value!" } + } +} + +# There is also another kind of exception: Control exceptions. +# Those are "good" exceptions, which happen when you change your program's flow, +# using operators like `return`, `next` or `last`. +# You can "catch" those with `CONTROL` (not 100% working in Rakudo yet). + +### Packages +# Packages are a way to reuse code. Packages are like "namespaces", and any +# element of the six model (`module`, `role`, `class`, `grammar`, `subset` +# and `enum`) are actually packages. (Packages are the lowest common denomitor) +# Packages are important - especially as Perl is well-known for CPAN, +# the Comprehensive Perl Archive Network. +# You usually don't use packages directly: you use `class Package::Name::Here;`, +# or if you only want to export variables/subs, you can use `module`: +module Hello::World { # Bracketed form + # If `Hello` doesn't exist yet, it'll just be a "stub", + # that can be redeclared as something else later. + # ... declarations here ... +} +module Parse::Text; # file-scoped form +grammar Parse::Text::Grammar { # A grammar is a package, which you could `use` +} + +# NOTE for Perl 5 users: even though the `package` keyword exists, +# the braceless form is invalid (to catch a "perl5ism"). This will error out: +# package Foo; # because Perl 6 will think the entire file is Perl 5 +# Just use `module` or the brace version of `package`. + +# You can use a module (bring its declarations into scope) with `use` +use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module +say from-json('[1]').perl; #=> [1] + +# As said before, any part of the six model is also a package. +# Since `JSON::Tiny` uses (its own) `JSON::Tiny::Actions` class, you can use it: +my $actions = JSON::Tiny::Actions.new; + +# We'll see how to export variables and subs in the next part: + +### Declarators +# In Perl 6, you get different behaviors based on how you declare a variable. +# You've already seen `my` and `has`, we'll now explore the others. + +## * `our` (happens at `INIT` time -- see "Phasers" below) +# Along with `my`, there are several others declarators you can use. +# The first one you'll want for the previous part is `our`. +# (All packagish things (`class`, `role`, etc) are `our` by default) +# it's like `my`, but it also creates a package variable: +module Foo::Bar { + our $n = 1; # note: you can't put a type constraint on an `our` variable + our sub inc { + our sub available { # If you try to make inner `sub`s `our`... + # Better know what you're doing (Don't !). + say "Don't do that. Seriously. You'd get burned."; + } + my sub unavailable { # `my sub` is the default + say "Can't access me from outside, I'm my !"; + } + } + + say ++$n; # lexically-scoped variables are still available +} +say $Foo::Bar::n; #=> 1 +Foo::Bar::inc; #=> 2 +Foo::Bar::inc; #=> 3 + +## * `constant` (happens at `BEGIN` time) +# You can use the `constant` keyword to declare a compile-time variable/symbol: +constant Pi = 3.14; +constant $var = 1; + +# And if you're wondering, yes, it can also contain infinite lists. +constant why-not = 5, 15 ... *; +say why-not[^5]; #=> 5 15 25 35 45 + +## * `state` (happens at run time, but only once) +# State variables are only executed one time +# (they exist in other langages such as C as `static`) +sub fixed-rand { + state $val = rand; + say $rand; +} +fixed-rand for ^10; # will print the same number 10 times + +# Note, however, that they exist separately in different enclosing contexts. +# If you declare a function with a `state` within a loop, it'll re-create the +# variable for each iteration of the loop. See: +for ^5 -> $a { + sub foo { + state $val = rand; # This will be a different value for every value of `$a` + } + for ^5 -> $b { + say foo; # This will print the same value 5 times, but only 5. + # Next iteration will re-run `rand`. + } +} + + + +### Phasers +# Phasers in Perl 6 are blocks that happen at determined points of time in your +# program. When the program is compiled, when a for loop runs, when you leave a +# block, when an exception gets thrown ... (`CATCH` is actually a phaser !) +# Some of them can be used for their return values, some of them can't +# (those that can have a "[*]" in the beginning of their explanation text). +# Let's have a look ! + +## * Compile-time phasers +BEGIN { say "[*] Runs at compile time, as soon as possible, only once" } +CHECK { say "[*] Runs at compile time, instead as late as possible, only once" } + +## * Run-time phasers +INIT { say "[*] Runs at run time, as soon as possible, only once" } +END { say "Runs at run time, as late as possible, only once" } + +## * Block phasers +ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" } +LEAVE { say "Runs everytime you leave a block, even when an exception happened. Repeats on loop blocks." } + +PRE { say "Asserts a precondition at every block entry, before ENTER (especially useful for loops)" } +POST { say "Asserts a postcondition at every block exit, after LEAVE (especially useful for loops)" } + +## * Block/exceptions phasers +sub { + KEEP { say "Runs when you exit a block successfully (without throwing an exception)" } + UNDO { say "Runs when you exit a block unsuccessfully (by throwing an exception)" } +} + +## * Loop phasers +for ^5 { + FIRST { say "[*] The first time the loop is run, before ENTER" } + NEXT { say "At loop continuation time, before LEAVE" } + LAST { say "At loop termination time, after LEAVE" } +} + +## * Role/class phasers +COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" } + +# They allow for cute trick or clever code ...: +say "This code took " ~ (time - CHECK time) ~ "s to run"; + +# ... or clever organization: +sub do-db-stuff { + ENTER $db.start-transaction; # New transaction everytime we enter the sub + KEEP $db.commit; # commit the transaction if all went well + UNDO $db.rollback; # or rollback if all hell broke loose +} + +### Statement prefixes +# Those act a bit like phasers: they affect the behavior of the following code. +# Though, they run in-line with the executable code, so they're in lowercase. +# (`try` and `start` are theoretically in that list, but explained somewhere else) +# Note: all of these (except start) don't need explicit brackets `{` and `}`. + +# - `do` (that you already saw) - runs a block or a statement as a term +# You can't normally use a statement as a value (or "term"): +# +# my $value = if True { 1 } # `if` is a statement - parse error +# +# This works: +my $a = do if True { 5 } # with `do`, `if` is now a term. + +# - `once` - Makes sure a piece of code only runs once +for ^5 { once say 1 }; #=> 1 + # Only prints ... once. +# Like `state`, they're cloned per-scope +for ^5 { sub { once say 1 }() } #=> 1 1 1 1 1 + # Prints once per lexical scope + +# - `gather` - Co-routine thread +# Gather allows you to `take` several values in an array, +# much like `do`, but allows you to take any expression. +say gather for ^5 { + take $_ * 3 - 1; + take $_ * 3 + 1; +} #=> -1 1 2 4 5 7 8 10 11 13 +say join ',', gather if False { + take 1; + take 2; + take 3; +} # Doesn't print anything. + +# - `eager` - Evaluate statement eagerly (forces eager context) +# Don't try this at home: +# +# eager 1..*; # this will probably hang for a while (and might crash ...). +# +# But consider: +constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything +# versus: +constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2 + +# - `lazy` - Defer actual evaluation until value is fetched (forces lazy context) +# Not yet implemented !! + +# - `sink` - An `eager` that discards the results (forces sink context) +constant nilthingie = sink for ^3 { .say } #=> 0 1 2 +say nilthingie.perl; #=> Nil + +# - `quietly` - Supresses warnings +# Not yet implemented ! + +# - `contend` - Attempts side effects under STM +# Not yet implemented ! + +### More operators thingies ! + +## Everybody loves operators ! Let's get more of them + +# The precedence list can be found here: +# http://perlcabal.org/syn/S03.html#Operator_precedence +# But first, we need a little explanation about associativity: + +# * Binary operators: +$a ! $b ! $c; # with a left-associative `!`, this is `($a ! $b) ! $c` +$a ! $b ! $c; # with a right-associative `!`, this is `$a ! ($b ! $c)` +$a ! $b ! $c; # with a non-associative `!`, this is illegal +$a ! $b ! $c; # with a chain-associative `!`, this is `($a ! $b) and ($b ! $c)` +$a ! $b ! $c; # with a list-associative `!`, this is `infix:<>` + +# * Unary operators: +!$a! # with left-associative `!`, this is `(!$a)!` +!$a! # with right-associative `!`, this is `!($a!)` +!$a! # with non-associative `!`, this is illegal + +## Create your own operators ! +# Okay, you've been reading all of that, so I guess I should try +# to show you something exciting. +# I'll tell you a little secret (or not-so-secret): +# In Perl 6, all operators are actually just funny-looking subroutines. + +# You can declare an operator just like you declare a sub: +sub prefix:<win>($winner) { # refer to the operator categories + # (yes, it's the "words operator" `<>`) + say "$winner Won !"; +} +win "The King"; #=> The King Won ! + # (prefix is before) + +# you can still call the sub with its "full name" +say prefix:<!>(True); #=> False + +sub postfix:<!>(Int $n) { + [*] 2..$n; # using the reduce meta-operator ... See below ;-) ! +} +say 5!; #=> 120 + # Postfix operators (after) have to come *directly* after the term. + # No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!` + + +sub infix:<times>(Int $n, Block $r) { # infix in the middle + for ^$n { + $r(); # You need the explicit parentheses to call the function in `$r`, + # else you'd be referring at the variable itself, like with `&r`. + } +} +3 times -> { say "hello" }; #=> hello + #=> hello + #=> hello + # You're very recommended to put spaces + # around your infix operator calls. + +# For circumfix and post-circumfix ones +sub circumfix:<[ ]>(Int $n) { + $n ** $n +} +say [5]; #=> 3125 + # circumfix is around. Again, not whitespace. + +sub postcircumfix:<{ }>(Str $s, Int $idx) { + # post-circumfix is + # "after a term, around something" + $s.substr($idx, 1); +} +say "abc"{1}; #=> b + # after the term `"abc"`, and around the index (1) + +# This really means a lot -- because everything in Perl 6 uses this. +# For example, to delete a key from a hash, you use the `:delete` adverb +# (a simple named argument underneath): +%h{$key}:delete; +# equivalent to: +postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that) +# It's *all* using the same building blocks! +# Syntactic categories (prefix infix ...), named arguments (adverbs), ..., +# - used to build the language - are available to you. + +# (you are, obviously, recommended against making an operator out of +# *everything* -- with great power comes great responsibility) + +## Meta operators ! +# Oh boy, get ready. Get ready, because we're delving deep +# into the rabbit's hole, and you probably won't want to go +# back to other languages after reading that. +# (I'm guessing you don't want to already at that point). +# Meta-operators, as their name suggests, are *composed* operators. +# Basically, they're operators that apply another operator. + +## * Reduce meta-operator +# It's a prefix meta-operator that takes a binary functions and +# one or many lists. If it doesn't get passed any argument, +# it either return a "default value" for this operator +# (a meaningless value) or `Any` if there's none (examples below). +# +# Otherwise, it pops an element from the list(s) one at a time, and applies +# the binary function to the last result (or the list's first element) +# and the popped element. +# +# To sum a list, you could use the reduce meta-operator with `+`, i.e.: +say [+] 1, 2, 3; #=> 6 +# equivalent to `(1+2)+3` +say [*] 1..5; #=> 120 +# equivalent to `((((1*2)*3)*4)*5)`. + +# You can reduce with any operator, not just with mathematical ones. +# For example, you could reduce with `//` to get +# the first defined element of a list: +say [//] Nil, Any, False, 1, 5; #=> False + # (Falsey, but still defined) + + +# Default value examples: +say [*] (); #=> 1 +say [+] (); #=> 0 + # meaningless values, since N*1=N and N+0=N. +say [//]; #=> (Any) + # There's no "default value" for `//`. + +# You can also call it with a function you made up, using double brackets: +sub add($a, $b) { $a + $b } +say [[&add]] 1, 2, 3; #=> 6 + +## * Zip meta-operator +# This one is an infix meta-operator than also can be used as a "normal" operator. +# It takes an optional binary function (by default, it just creates a pair), +# and will pop one value off of each array and call its binary function on these +# until it runs out of elements. It runs the an array with all these new elements. +(1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function makes an array +1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function + +# Since `Z` is list-associative (see the list above), +# you can use it on more than one list +(True, False) Z|| (False, False) Z|| (False, False); # (True, False) + +# And, as it turns out, you can also use the reduce meta-operator with it: +[Z||] (True, False), (False, False), (False, False); # (True, False) + + +## And to end the operator list: + +## * Sequence operator +# The sequence operator is one of Perl 6's most powerful features: +# it's composed of first, on the left, the list you want Perl 6 to deduce from +# (and might include a closure), and on the right, a value or the predicate +# that says when to stop (or Whatever for a lazy infinite list). +my @list = 1, 2, 3 ... 10; # basic deducing +#my @list = 1, 3, 6 ... 10; # this throws you into an infinite loop, + # because Perl 6 can't figure out the end +my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element + # (the iteration when the predicate matches). +my @list = 1, 3, 9 ... * > 30; # you can use a predicate + # (with the Whatever Star, here). +my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above) + +my @fib = 1, 1, *+* ... *; # lazy infinite list of fibonacci series, + # computed using a closure! +my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above) +my @fib = 1, 1, { $^a + $^b } ... *; #(... also equivalent to the above) +# $a and $b will always take the previous values, meaning here +# they'll start with $a = 1 and $b = 1 (values we set by hand). +# then $a = 1 and $b = 2 (result from previous $a+$b), and so on. + +say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55 + # (using a range as the index) +# Note : as for ranges, once reified, elements aren't re-calculated. +# That's why `@primes[^100]` will take a long time the first time you print +# it, then be instant. + +### Regular Expressions +# I'm sure a lot of you have been waiting for this one. +# Well, now that you know a good deal of Perl 6 already, we can get started. +# First off, you'll have to forget about "PCRE regexps" (perl-compatible regexps). +# +# IMPORTANT: Don't skip them because you know PCRE. They're different. +# Some things are the same (like `?`, `+`, and `*`), +# but sometimes the semantics change (`|`). +# Make sure you read carefully, because you might trip over a new behavior. +# +# Perl 6 has many features related to RegExps. After all, Rakudo parses itself. +# We're first going to look at the syntax itself, +# then talk about grammars (PEG-like), differences between +# `token`, `regex` and `rule` declarators, and some more. +# Side note: you still have access to PCRE regexps using the `:P5` modifier. +# (we won't be discussing this in this tutorial, however) +# +# In essence, Perl 6 natively implements PEG ("Parsing Expression Grammars"). +# The pecking order for ambiguous parses is determined by a multi-level +# tie-breaking test: +# - Longest token matching. `foo\s+` beats `foo` (by 2 or more positions) +# - Longest literal prefix. `food\w*` beats `foo\w*` (by 1) +# - Declaration from most-derived to less derived grammars +# (grammars are actually classes) +# - Earliest declaration wins +say so 'a' ~~ /a/; #=> True +say so 'a' ~~ / a /; # More readable with some spaces! + +# In all our examples, we're going to use the smart-matching operator against +# a regexp. We're converting the result using `so`, but in fact, it's +# returning a `Match` object. They know how to respond to list indexing, +# hash indexing, and return the matched string. +# The results of the match are available as `$/` (implicitly lexically-scoped). +# You can also use the capture variables (`$0`, `$1`, ... starting at 0, not 1 !). +# +# You can also note that `~~` does not perform start/end checking +# (meaning the regexp can be matched with just one char of the string), +# we're going to explain later how you can do it. + +# In Perl 6, you can have any alphanumeric as a literal, +# everything else has to be escaped, using a backslash or quotes. +say so 'a|b' ~~ / a '|' b /; # `True`. Wouln't mean the same if `|` wasn't escaped +say so 'a|b' ~~ / a \| b /; # `True`. Another way to escape it. + +# The whitespace in a regexp is actually not significant, +# unless you use the `:s` (`:sigspace`, significant space) modifier. +say so 'a b c' ~~ / a b c /; # `False`. Space is not significant here +say so 'a b c' ~~ /:s a b c /; # `True`. We added the modifier `:s` here. + +# It is, however, important as for how modifiers (that you're gonna see just below) +# are applied ... + +## Quantifying - `?`, `+`, `*` and `**`. +# - `?` - 0 or 1 +so 'ac' ~~ / a b c /; # `False` +so 'ac' ~~ / a b? c /; # `True`, the "b" matched 0 times. +so 'abc' ~~ / a b? c /; # `True`, the "b" matched 1 time. + +# ... As you read just before, whitespace is important because it determines +# which part of the regexp is the target of the modifier: +so 'def' ~~ / a b c? /; # `False`. Only the `c` is optional +so 'def' ~~ / ab?c /; # `False`. Whitespace is not significant +so 'def' ~~ / 'abc'? /; # `True`. The whole "abc" group is optional. + +# Here (and below) the quantifier applies only to the `b` + +# - `+` - 1 or more +so 'ac' ~~ / a b+ c /; # `False`; `+` wants at least one matching +so 'abc' ~~ / a b+ c /; # `True`; one is enough +so 'abbbbc' ~~ / a b+ c /; # `True`, matched 4 "b"s + +# - `*` - 0 or more +so 'ac' ~~ / a b* c /; # `True`, they're all optional. +so 'abc' ~~ / a b* c /; # `True` +so 'abbbbc' ~~ / a b* c /; # `True` +so 'aec' ~~ / a b* c /; # `False`. "b"(s) are optional, not replaceable. + +# - `**` - (Unbound) Quantifier +# If you squint hard enough, you might understand +# why exponentation is used for quantity. +so 'abc' ~~ / a b ** 1 c /; # `True` (exactly one time) +so 'abc' ~~ / a b ** 1..3 c /; # `True` (one to three times) +so 'abbbc' ~~ / a b ** 1..3 c /; # `True` +so 'abbbbbbc' ~~ / a b ** 1..3 c /; # `False` (too much) +so 'abbbbbbc' ~~ / a b ** 3..* c /; # `True` (infinite ranges are okay) + +# - `<[]>` - Character classes +# Character classes are the equivalent of PCRE's `[]` classes, but +# they use a more perl6-ish syntax: +say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa' +# You can use ranges: +say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'aeiou' +# Just like in normal regexes, if you want to use a special character, escape it +# (the last one is escaping a space) +say 'he-he !' ~~ / 'he-' <[ a..z \! \ ]> + /; #=> 'he-he !' +# You'll get a warning if you put duplicate names +# (which has the nice effect of catching the wrote quoting:) +'he he' ~~ / <[ h e ' ' ]> /; # Warns "Repeated characters found in characters class" + +# You can also negate them ... (equivalent to `[^]` in PCRE) +so 'foo' ~~ / <-[ f o ]> + /; # False + +# ... and compose them: : +so 'foo' ~~ / <[ a..z ] - [ f o ]> + /; # False (any letter except f and o) +so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /; # True (no letter except f and o) +so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the left part) + +## Grouping and capturing +# Group: you can group parts of your regexp with `[]`. +# These groups are *not* captured (like PCRE's `(?:)`). +so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing +so 'fooABCABCbar' ~~ / foo [ A B C ] + bar /; +# The previous line returns `True`. +# We match the "abc" 1 or more time (the `+` was applied to the group). + +# But this does not go far enough, because we can't actually get back what +# we matched. +# Capture: We can actually *capture* the results of the regexp, using parentheses. +so 'fooABCABCbar' ~~ / foo ( A B C ) + bar /; # `True`. (using `so` here, `$/` below) + +# So, starting with the grouping explanations. +# As we said before, our `Match` object is available as `$/`: +say $/; # Will print some weird stuff (we'll explain) (or "Nil" if nothing matched). + +# As we also said before, it has array indexing: +say $/[0]; #=> ｢ABC｣ ｢ABC｣ + # These weird brackets are `Match` objects. + # Here, we have an array of these. +say $0; # The same as above. + +# Our capture is `$0` because it's the first and only one capture in the regexp. +# You might be wondering why it's an array, and the answer is simple: +# Some capture (indexed using `$0`, `$/[0]` or a named one) will be an array +# IFF it can have more than one element +# (so, with `*`, `+` and `**` (whatever the operands), but not with `?`). +# Let's use examples to see that: +so 'fooABCbar' ~~ / foo ( A B C )? bar /; # `True` +say $/[0]; #=> ｢ABC｣ +say $0.WHAT; #=> (Match) + # It can't be more than one, so it's only a single match object. +so 'foobar' ~~ / foo ( A B C )? bar /; #=> True +say $0.WHAT; #=> (Any) + # This capture did not match, so it's empty +so 'foobar' ~~ / foo ( A B C ) ** 0..1 bar /; # `True` +say $0.WHAT; #=> (Array) + # A specific quantifier will always capture an Array, + # may it be a range or a specific value (even 1). + +# The captures are indexed per nesting. This means a group in a group will be nested +# under its parent group: `$/[0][0]`, for this code: +'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /; +say $/[0].Str; #=> hello~ +say $/[0][0].Str; #=> ~ + +# This stems from a very simple fact: `$/` does not contain strings, integers or arrays, +# it only contains match objects. These contain the `.list`, `.hash` and `.Str` methods. +# (but you can also just use `match<key>` for hash access and `match[idx]` for array access) +say $/[0].list.perl; #=> (Match.new(...),).list + # We can see it's a list of Match objects. Those contain a bunch of infos: + # where the match started/ended, the "ast" (see actions later), etc. + # You'll see named capture below with grammars. + +## Alternatives - the `or` of regexps +# WARNING: They are DIFFERENT from PCRE regexps. +so 'abc' ~~ / a [ b | y ] c /; # `True`. Either "b" or "y". +so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ... + +# The difference between this `|` and the one you're used to is LTM. +# LTM means "Longest Token Matching". This means that the engine will always +# try to match as much as possible in the strng +'foo' ~~ / fo | foo /; # `foo`, because it's longer. +# To decide which part is the "longest", it first splits the regex in two parts: +# The "declarative prefix" (the part that can be statically analyzed) +# and the procedural parts. +# Declarative prefixes include alternations (`|`), conjuctions (`&`), +# sub-rule calls (not yet introduced), literals, characters classes and quantifiers. +# The latter include everything else: back-references, code assertions, +# and other things that can't traditionnaly be represented by normal regexps. +# +# Then, all the alternatives are tried at once, and the longest wins. +# Exemples: +# DECLARATIVE | PROCEDURAL +/ 'foo' \d+ [ <subrule1> || <subrule2> ] /; +# DECLARATIVE (nested groups are not a problem) +/ \s* [ \w & b ] [ c | d ] /; +# However, closures and recursion (of named regexps) are procedural. +# ... There are also more complicated rules, like specificity +# (literals win over character classes) + +# Note: the first-matching `or` still exists, but is now spelled `||` +'foo' ~~ / fo || foo /; # `fo` now. + + + + +### Extra: the MAIN subroutime +# The `MAIN` subroutine is called when you run a Perl 6 file directly. +# It's very powerful, because Perl 6 actually parses the argument +# and pass them as such to the sub. It also handles named argument (`--foo`) +# and will even go as far as to autogenerate a `--help` +sub MAIN($name) { say "Hello, $name !" } +# This produces: +# $ perl6 cli.pl +# Usage: +# t.pl <name> + +# And since it's a regular Perl 6 sub, you can haz multi-dispatch: +# (using a "Bool" for the named argument so that we can do `--replace` +# instead of `--replace=1`) +subset File of Str where *.IO.d; # convert to IO object to check the file exists + +multi MAIN('add', $key, $value, Bool :$replace) { ... } +multi MAIN('remove', $key) { ... } +multi MAIN('import', File, Str :$as) { ... } # omitting parameter name +# This produces: +# $ perl 6 cli.pl +# Usage: +# t.pl [--replace] add <key> <value> +# t.pl remove <key> +# t.pl [--as=<Str>] import (File) +# As you can see, this is *very* powerful. +# It even went as far as to show inline the constants. +# (the type is only displayed if the argument is `$`/is named) + +### +### APPENDIX A: +### +### List of things +### + +# It's considered by now you know the Perl6 basics. +# This section is just here to list some common operations, +# but which are not in the "main part" of the tutorial to bloat it up + +## Operators + + +## * Sort comparison +# They return one value of the `Order` enum : `Less`, `Same` and `More` +# (which numerify to -1, 0 or +1). +1 <=> 4; # sort comparison for numerics +'a' leg 'b'; # sort comparison for string +$obj eqv $obj2; # sort comparison using eqv semantics + +## * Generic ordering +3 before 4; # True +'b' after 'a'; # True + +## * Short-circuit default operator +# Like `or` and `||`, but instead returns the first *defined* value : +say Any // Nil // 0 // 5; #=> 0 + +## * Short-circuit exclusive or (XOR) +# Returns `True` if one (and only one) of its arguments is true +say True ^^ False; #=> True +## * Flip Flop +# The flip flop operators (`ff` and `fff`, equivalent to P5's `..`/`...`). +# are operators that take two predicates to test: +# They are `False` until their left side returns `True`, then are `True` until +# their right side returns `True`. +# Like for ranges, you can exclude the iteration when it became `True`/`False` +# by using `^` on either side. +# Let's start with an example : +for <well met young hero we shall meet later> { + # by default, `ff`/`fff` smart-match (`~~`) against `$_`: + if 'met' ^ff 'meet' { # Won't enter the if for "met" + # (explained in details below). + .say + } + + if rand == 0 ff rand == 1 { # compare variables other than `$_` + say "This ... probably will never run ..."; + } +} +# This will print "young hero we shall meet" (excluding "met"): +# the flip-flop will start returning `True` when it first encounters "met" +# (but will still return `False` for "met" itself, due to the leading `^` +# on `ff`), until it sees "meet", which is when it'll start returning `False`. + +# The difference between `ff` (awk-style) and `fff` (sed-style) is that +# `ff` will test its right side right when its left side changes to `True`, +# and can get back to `False` right away +# (*except* it'll be `True` for the iteration that matched) - +# While `fff` will wait for the next iteration to +# try its right side, once its left side changed: +.say if 'B' ff 'B' for <A B C B A>; #=> B B + # because the right-hand-side was tested + # directly (and returned `True`). + # "B"s are printed since it matched that time + # (it just went back to `False` right away). +.say if 'B' fff 'B' for <A B C B A>; #=> B C B + # The right-hand-side wasn't tested until + # `$_` became "C" + # (and thus did not match instantly). + +# A flip-flop can change state as many times as needed: +for <test start print it stop not printing start print again stop not anymore> { + .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop", + #=> "print this printing again" +} + +# you might also use a Whatever Star, +# which is equivalent to `True` for the left side or `False` for the right: +for (1, 3, 60, 3, 40, 60) { # Note: the parenthesis are superfluous here + # (sometimes called "superstitious parentheses") + .say if $_ > 50 ff *; # Once the flip-flop reaches a number greater than 50, + # it'll never go back to `False` + #=> 60 3 40 60 +} + +# You can also use this property to create an `If` +# that'll not go through the first time : +for <a b c> { + .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`, + # but the `^` makes it *not run* on the first iteration + #=> b c +} + + +# - `===` is value identity and uses `.WHICH` on the objects to compare them +# - `=:=` is container identity and uses `VAR()` on the objects to compare them + +``` + +If you want to go further, you can: + + - Read the [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). This is probably the greatest source of Perl 6 information, snippets and such. + - Come along on `#perl6` at `irc.freenode.net`. The folks here are always helpful. + - Check the [source of Perl 6's functions and classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is mainly written in Perl 6 (with a lot of NQP, "Not Quite Perl", a Perl 6 subset easier to implement and optimize). + - Read [the language design documents](http://design.perl6.org). They explain P6 from an implementor point-of-view, but it's still very interesting. + diff --git a/php.html.markdown b/php.html.markdown index e81b88fd..2b1fe1dc 100644 --- a/php.html.markdown +++ b/php.html.markdown @@ -1,5 +1,5 @@ --- -language: php +language: PHP contributors: - ["Malcolm Fell", "http://emarref.net/"] - ["Trismegiste", "https://github.com/Trismegiste"] @@ -9,9 +9,9 @@ filename: learnphp.php This document describes PHP 5+. ```php -<?php // PHP code must be enclosed with <?php ? > tags +<?php // PHP code must be enclosed with <?php tags -// If your php file only contains PHP code, it is best practise +// If your php file only contains PHP code, it is best practice // to omit the php closing tag. // Two forward slashes start a one-line comment. @@ -31,7 +31,8 @@ echo "World\n"; // Prints "World" with a line break // (all statements must end with a semicolon) // Anything outside <?php tags is echoed automatically -?>Hello World Again! +?> +Hello World Again! <?php @@ -58,6 +59,9 @@ $float = 1.234; $float = 1.2e3; $float = 7E-10; +// Delete variable +unset($int1); + // Arithmetic $sum = 1 + 1; // 2 $difference = 2 - 1; // 1 @@ -68,7 +72,7 @@ $quotient = 2 / 1; // 2 $number = 0; $number += 1; // Increment $number by 1 echo $number++; // Prints 1 (increments after evaluation) -echo ++$number; // Prints 3 (increments before evalutation) +echo ++$number; // Prints 3 (increments before evaluation) $number /= $float; // Divide and assign the quotient to $number // Strings should be enclosed in single quotes; @@ -101,6 +105,21 @@ echo 'This string ' . 'is concatenated'; /******************************** + * Constants + */ + +// A constant is defined by using define() +// and can never be changed during runtime! + +// a valid constant name starts with a letter or underscore, +// followed by any number of letters, numbers, or underscores. +define("FOO", "something"); + +// access to a constant is possible by direct using the choosen name +echo 'This outputs '.FOO; + + +/******************************** * Arrays */ @@ -120,6 +139,11 @@ echo $associative['One']; // prints 1 $array = ['One', 'Two', 'Three']; echo $array[0]; // => "One" +// Add an element to the end of an array +$array[] = 'Four'; + +// Remove element from array +unset($array[3]); /******************************** * Output @@ -160,6 +184,11 @@ $y = 0; echo $x; // => 2 echo $z; // => 0 +// Dumps type and value of variable to stdout +var_dump($z); // prints int(0) + +// Prints variable to stdout in human-readable format +print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three ) /******************************** * Logic @@ -183,9 +212,17 @@ assert($c >= $d); // The following will only be true if the values match and are the same type. assert($c === $d); assert($a !== $d); -assert(1 == '1'); +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; @@ -235,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'; @@ -424,6 +473,13 @@ class MyClass static $staticVar = 'static'; + // Static variables and their visibility + public static $publicStaticVar = 'publicStatic'; + // Accessible within the class only + private static $privateStaticVar = 'privateStatic'; + // Accessible from the class and subclasses + protected static $protectedStaticVar = 'protectedStatic'; + // Properties must declare their visibility public $property = 'public'; public $instanceProp; @@ -442,17 +498,26 @@ class MyClass print 'MyClass'; } + //final keyword would make a function unoverridable final function youCannotOverrideMe() { } +/* + * Declaring class properties or methods as static makes them accessible without + * needing an instantiation of the class. A property declared as static can not + * be accessed with an instantiated class object (though a static method can). + */ + public static function myStaticMethod() { print 'I am static'; } } +// Class constants can always be accessed statically echo MyClass::MY_CONST; // Outputs 'value'; + echo MyClass::$staticVar; // Outputs 'static'; MyClass::myStaticMethod(); // Outputs 'I am static'; @@ -634,10 +699,14 @@ $cls = new SomeOtherNamespace\MyClass(); ## More Information -Visit the [official PHP documentation](http://www.php.net/manual/) for reference and community input. +Visit the [official PHP documentation](http://www.php.net/manual/) for reference +and community input. -If you're interested in up-to-date best practices, visit [PHP The Right Way](http://www.phptherightway.com/). +If you're interested in up-to-date best practices, visit +[PHP The Right Way](http://www.phptherightway.com/). -If you're coming from a language with good package management, check out [Composer](http://getcomposer.org/). +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). +For common standards, visit the PHP Framework Interoperability Group's +[PSR standards](https://github.com/php-fig/fig-standards).
\ No newline at end of file diff --git a/pl-pl/brainfuck-pl.html.markdown b/pl-pl/brainfuck-pl.html.markdown new file mode 100644 index 00000000..69d814c4 --- /dev/null +++ b/pl-pl/brainfuck-pl.html.markdown @@ -0,0 +1,93 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Jakub Młokosiewicz", "https://github.com/hckr"] +lang: pl-pl +--- + +Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo +minimalistycznym, kompletnym w sensie Turinga, językiem programowania. +Zawiera zaledwie 8 poleceń. + +Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia +[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). + +``` +Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane. + +Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek +zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę. + +Oto osiem poleceń brainfucka: ++ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki +- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki +> : przesuwa wskaźnik na następną komórkę (w prawo) +< : przesuwa wskaźnik na poprzednią komórkę (w lewo) +. : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A') +, : wczytuje (jeden) znak z wejścia do bieżącej komórki + (konkretnie jego numer z tabeli ASCII) +[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do + odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji +] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do + następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [ + +[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [ +musi być zakończona ]. + +Zobaczmy kilka prostych programów w brainfucku. + + +++++++ [ > ++++++++++ < - ] > +++++ . + +Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6. +Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([) +i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest +dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program +przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje). + +W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy +komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją +pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2. +65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę. + + +, [ > + < - ] > . + +Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1. +Następnie zaczyna się pętla, w której znajdują się następujące instrukcje: +przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2, +powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli +wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie +poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na +komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie +jej wartości (w formie znaku ASCII) na wyjście. + +Zauważ, że odstępy służą wyłącznie poprawie czytelności. +Równie dobrze można powyższy program zapisać tak: + +,[>+<-]>. + + +Spróbuj odgadnąć, co robi poniższy program: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Ten program pobiera z wejścia dwie liczby i je mnoży. + +Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna, +warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2 +i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2, +inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia +wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla +nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także +wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2. +Ostatecznie wynik działania znajduje się w komórce #3. +``` + +I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz +napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka +w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli +jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku. diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown new file mode 100644 index 00000000..9e8ade5b --- /dev/null +++ b/pl-pl/perl-pl.html.markdown @@ -0,0 +1,169 @@ +--- +name: perl +category: language +language: perl +filename: learnperl.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] + - ["Michał Kupczyński", "http://github.com/ukoms"] +lang: pl-pl +--- + +Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania +z ponad 25 latami nieustannego rozwoju. + +Perl 5 używany jest na ponad 100 różnych platformach (od przenośnych do w +pełni stacjonarnych) i nadaje się zarówno do szybkiego prototypowania jak +i projektów deweloperskich prowadzonych na szeroką skalę. + +```perl + +# Pojedyncza linia komentarza zaczyna się od znaku hasha (płotka) "#". + +#### Typy zmiennych w Perlu + +# Zmienna zaczyna się od symbolu dolara "$". +# Prawidłowa nazwa zmiennej zaczyna się od litery lub podkreślnika "_", +# po których następuje dowolna ilość liter, cyfr i podkreślników. + +### W Perlu występują trzy główne typy zmiennych: skalary, tablice i hasze. + +## Skalary +# Skalar przechowuje pojedynczą wartość: +my $zwierze = "wielbłąd"; +my $odpowiedź = 42; + +# Wartości skalarne mogą być ciągami znaków, liczbami całkowitymi lub +# zmiennoprzecinkowymi, zaś Perl automatycznie dokonuje konwersji pomiędzy nimi, +# w zależności od wykonywanego kodu/kontekstu. + +## Tablice +# Tablica przechowuje listę wartości: +my @zwierzęta = ("wielbłąd", "alpaka", "sowa"); +my @liczby = (23, 42, 69); +my @mieszanka = ("wielbłąd", 42, 1.23); + +## Hasze +# Hasz przechowuje zestawy par klucz-wartość: +my %kolor_owocu = ('jabłko', 'czerwony', 'banan', 'żółty'); + +# Możesz używać białych znaków (spacje, tabulatory) i operatora strzałki "=>" +# by czytelniej sformatować zapis hasza: +my %kolor_owocu = ( + jabłko => 'czerwony', + banan => 'żółty', +); + +# Skalary, tablice i hasze są bardziej wyczerpująco udokumentowane w dokumencie +# [perldoc perldata](http://perldoc.perl.org/perldata.html). + +# Bardziej złożone typy danych mogą być stworzone poprzez używanie referencji, +# które pozwalają Ci zbudować listy i hasze wewnątrz list i haszy. + +#### Warunki logiczne i pętle + +# W Perlu występują typowe warunki i pętle. +if ($var) { + ... +} elsif ($var eq 'bar') { + ... +} else { + ... +} + +unless (warunek) { + ... +} +# Powyższy zapis jest równoznaczny zapisowi "if (!warunek)" + +# Perlowy skrócony zapis warunków: +print "Siema!" if $rozochocony; +print "Nie mamy bananów" unless $banany; + +# Pętla while +while (warunek) { + ... +} + +# Pętle for oraz foreach +for ($i = 0; $i <= $max; $i++) { + ... +} + +foreach (@tablica) { + print "Tym elementem jest $_\n"; +} + +# lub + +foreach my $iterator (@tablica) { + print "Iterowanym elementem jest $iterator\n"; +} + +#### Wyrażenia regularne + +# Perlowe wyrażenia regularne są tematem tak rozległym, jak wymagającym. +# Istnieje ogromna ilość dokumentacji w artykułach takich jak +# [perlrequick](http://perldoc.perl.org/perlrequick.html), +# [perlretut](http://perldoc.perl.org/perlretut.html) i inne. +# W dużym skrócie, podstawy perlowych wyrażeń regularnych są następujące: + +# Proste dopasowanie: +if (/foo/) { ... } # prawda jeżeli $_ zawiera "foo" +if ($a =~ /foo/) { ... } # prawda jeżeli $a zawiera "foo" + +# Prosta zamiana: +# Zamienia "foo" na "bar" w zmiennej $a +$a =~ s/foo/bar/; +# Zamienia WSZYSTKIE WYSTĄPIENIA "foo" na "bar" w zmiennej $a +$a =~ s/foo/bar/g; + +#### Pliki i I/O + +# Możesz otworzyć plik do odczytu lub zapisu używając funkcji "open ()". +open (my $odczyt, "<", "odczyt.txt") or die "Błąd otwierania input.txt: $!"; +open (my $zapis, ">", "zapis.txt") or die "Błąd otwierania output.txt: $!"; +open (my $dopisanie, ">>", "my.log") or die "Błąd otwierania my.log: $!"; + +# Pliki możesz odczytywać z otworzonego handlera używając operatora "<>" +# (operator diamentowy). W kontekście skalarnym (przypisanie wyniku do skalara) +# operator ten zczytuje pojedynczą linię pliku, w kontekście listowym +# (przypisanie wyniku do tablicy) zczytuje całą zawartość pliku, przypisując +# każdą linię jako kolejny element listy: +my $linia = <$in>; +my @linie = <$in>; + +#### Perlowe funkcje (procedury) + +# Pisanie funkcji (procedur) jest proste: +sub logger { + my $wiadomosc_do_loga = shift; + open (my HANDLER, ">>", "my.log") or die "Błąd otwierania my.log: $!"; + print HANDLER $wiadomosc_do_loga; +} + +# Teraz można używać napisanej funkcji, tak jak każdej innej wbudowanej +# funkcji perlowej: +logger ("Mamy funkcję perlową"); + +``` + +#### Używanie modułów perlowych + +Moduły perlowe dostarczają szeroki wachlarz możliwości, byś nie musiał +wynajdywać koła na nowo. Moduły te można pobrać z [CPAN](http://www.cpan.org). +Sam Perl zawiera w swoich dystrybucjach kilka najpopularniejszych modułów +z repozytorium [CPAN](http://www.cpan.org). + +Najczęściej zadawane pytania [perlfaq](http://perldoc.perl.org/perlfaq.html) +- zawierają pytania i odpowiedzi dotyczące wielu typowo realizowanych zadań. +Często znajdziesz tam również sugestie dotyczące użycia najlepszego modułu +z repozytorium CPAN do zrealizowania konkretnego zadania. + + +#### Do doczytania + + - [perl-tutorial](http://perl-tutorial.org/) + - [Naucz się Perla na www.perl.com](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - wbudowane w Perla: `perldoc perlintro`
\ No newline at end of file diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown new file mode 100644 index 00000000..c3e8287a --- /dev/null +++ b/pl-pl/python-pl.html.markdown @@ -0,0 +1,637 @@ +--- +name: python +category: language +language: python +filename: learnpython-pl.py +contributors: + - ["Louie Dinh", "http://ldinh.ca"] + - ["Amin Bandali", "http://aminbandali.com"] + - ["Andre Polykanine", "https://github.com/Oire"] +translators: + - ["Dominik Krzemiński", "https://github.com/dokato"] +lang: pl-pl +--- + +Python został opracowany przez Guido Van Rossuma na początku lat 90-tych. +Obecnie jest jednym z najbardziej popularnych języków programowania. +Zakochałem się w Pythonie dzięki porządkowi, jaki utrzymywany jest w kodzie. +To po prostu wykonywalny pseudokod. + +Zapraszam do kontaktu. Złapiecie nas na: +- kontakt polski: raymon92 [at] [google's email service] +- kontakt angielski: [@louiedinh](http://twitter.com/louiedinh) lub louiedinh [at] [google's email service] + +Uwaga: Ten artykuł odnosi się do wersji Pythona 2.7, ale powinien +działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stronie głównej. + +```python +# -*- coding: utf-8 -*- + +# Pojedyncze komentarze oznaczamy takim symbolem. + +""" Wielolinijkowe napisy zapisywane są przy użyciu + trzech znaków cudzysłowiu i często + wykorzystywane są jako komentarze. +""" + +#################################################### +## 1. Podstawowe typy danych i operatory +#################################################### + +# Liczby to liczby +3 # => 3 + +# Matematyka jest intuicyjna +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7 + +# Dzielenie może być kłopotliwe. Poniższe to dzielenie +# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany. +5 / 2 # => 2 + +# Aby to naprawić musimy powiedzieć nieco o liczbach zmiennoprzecinkowych. +2.0 # To liczba zmiennoprzecinkowa, tzw. float +11.0 / 4.0 # => 2.75 ahhh...znacznie lepiej + +# Wynik dzielenia całkowitoliczbowego jest obcinany dla liczb +# dodatnich i ujemnych. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # działa też na floatach +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Operator modulo - wyznaczanie reszty z dzielenia +7 % 3 # => 1 + +# Potęgowanie (x do potęgi ytej) +2**4 # => 16 + +# Wymuszanie pierwszeństwa w nawiasach +(1 + 3) * 2 # => 8 + +# Operacje logiczne +# Zauważ, że przy "and" i "or" trzeba zwracać uwagę na rozmiar liter +True and False #=> False # Fałsz +False or True #=> True # Prawda + +# Zauważ, że operatorów logicznych można używać z intami +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +k1 == True #=> True + +# aby zanegować użyj "not" +not True # => False +not False # => True + +# Równość == +1 == 1 # => True +2 == 1 # => False + +# Nierówność != +1 != 1 # => False +2 != 1 # => True + +# Więcej porównań +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Porównania można układać w łańcuch! +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# Napisy (typ string) tworzone są przy użyciu cudzysłowów " lub ' +"Jestem napisem." +'Ja też jestem napisem.' + +# Napisy można dodawać! +"Witaj " + "świecie!" # => "Witaj świecie!" + +# ... a nawet mnożone +"Hej" * 3 # => "HejHejHej" + +# Napis może być traktowany jako lista znaków +"To napis"[0] # => 'T' + +# % może być używane do formatowania napisów: +"%s są %s" % ("napisy", "fajne") + +# Jednak nowszym sposobem formatowania jest metoda "format". +# Ta metoda jest obecnie polecana: +"{0} są {1}".format("napisy", "fajne") +# Jeśli nie chce ci się liczyć użyj słów kluczowych. +"{imie} chce zjeść {jadlo}".format(imie="Bob", jasno="lasagne") + +# None jest obiektem +None # => None + +# Nie używaj "==" w celu porównania obiektów z None +# Zamiast tego użyj "is" +"etc" is None # => False +None is None # => True + +# Operator 'is' testuje identyczność obiektów. To nie jest zbyt +# pożyteczne, gdy działamy tylko na prostych wartościach, +# ale przydaje się, gdy mamy do czynienia z obiektami. + +# None, 0, i pusty napis "" są odpowiednikami logicznego False. +# Wszystkie inne wartości są True +bool(0) # => False +bool("") # => False + + +#################################################### +## 2. Zmienne i zbiory danych +#################################################### + +# Python ma wyrażenie wypisujące "print" we wszystkich wersjach 2.x, ale +# zostało usunięte z wersji 3. +print "Jestem Python. Miło poznać!" +# Python ma też funkcję "print" dostępną w wersjach 2.7 and 3... +# ale w 2.7 musisz dodać import (odkomentuj): +# from __future__ import print_function +print("Ja też jestem Python! ") + +# Nie trzeba deklarować zmiennych przed przypisaniem. +jakas_zmienna = 5 # Konwencja mówi: używaj małych znaków i podłogi _ +jakas_zmienna # => 5 + +# Próba dostępu do niezadeklarowanej zmiennej da błąd. +# Przejdź do sekcji Obsługa wyjątków po więcej... +inna_zmienna # Wyrzuca nazwę błędu + +# "if" może być użyte jako wyrażenie +"huraaa!" if 3 > 2 else 2 # => "huraaa!" + +# Listy: +li = [] +# Możesz zacząć od wypełnionej listy +inna_li = [4, 5, 6] + +# Dodaj na koniec używając "append" +li.append(1) # li to teraz [1] +li.append(2) # li to teraz [1, 2] +li.append(4) # li to teraz [1, 2, 4] +li.append(3) # li to teraz [1, 2, 4, 3] +# Usuwanie z konca da "pop" +li.pop() # => 3 a li stanie się [1, 2, 4] +# Dodajmy ponownie +li.append(3) # li to znowu [1, 2, 4, 3]. + +# Dostęp do list jak do każdej tablicy +li[0] # => 1 +# Użyj = aby nadpisać wcześniej wypełnione miejsca w liście +li[0] = 42 +li[0] # => 42 +li[0] = 1 # Uwaga: ustawiamy starą wartość +# Tak podglądamy ostatni element +li[-1] # => 3 + +# Jeżeli wyjdziesz poza zakres... +li[4] # ... zobaczysz IndexError + +# Możesz tworzyć wyniki. +li[1:3] # => [2, 4] +# Bez początku +li[2:] # => [4, 3] +# Omijamy koniec +li[:3] # => [1, 2, 4] +# Wybierz co drugi +li[::2] # =>[1, 4] +# Odwróć listę +li[::-1] # => [3, 4, 2, 1] +# Użyj kombinacji powyższych aby tworzyć bardziej skomplikowane wycinki +# li[poczatek:koniec:krok] + +# Usuń element używając "del" +del li[2] # li to teraz [1, 2, 3] + +# Listy można dodawać +li + inna_li # => [1, 2, 3, 4, 5, 6] +# Uwaga: wartości poszczególnych list się nie zmieniają. + +# Do łączenia list użyj "extend()" +li.extend(other_li) # li to teraz [1, 2, 3, 4, 5, 6] + +# Sprawdź czy jest w liście używając "in" +1 in li # => True + +# "len()" pokazuje długość listy +len(li) # => 6 + + +# Krotki (tuple) są jak listy, ale nie można ich modyfikować. +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # wyrzuci TypeError + +# Ale wielu akcji dla list możesz używać przy krotkach +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# Można rozpakować krotki i listy do poszczególych zmiennych +a, b, c = (1, 2, 3) # a to teraz 1, b jest 2, a c to 3 +# Jeżeli zapomnisz nawiasów automatycznie tworzone są krotki +d, e, f = 4, 5, 6 +# Popatrz jak prosto zamienić wartości +e, d = d, e # d to teraz 5 a e to 4 + + +# Słowniki są również pożyteczne +pusty_slownik = {} +# Tu tworzymy wypełniony: +pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3} + +# Podglądany wartość +pelen_slownik["one"] # => 1 + +# Wypisz wszystkie klucze używając "keys()" +pelen_slownik.keys() # => ["trzy", "dwa", "raz"] +# Uwaga: słowniki nie gwarantują kolejności występowania kluczy. + +# A teraz wszystkie wartości "values()" +pelen_slownik.values() # => [3, 2, 1] +# Uwaga: to samo dotyczy wartości. + +# Sprawdzanie czy występuje to "in" +"raz" in pelen_slownik # => True +1 in pelen_slownik # => False + +# Próba dobrania się do nieistniejącego klucza da KeyError +pelen_slownik["cztery"] # KeyError + +# Użyj "get()" method aby uniknąć KeyError +pelen_slownik.get("raz") # => 1 +pelen_slownik.get("cztery") # => None +# Metoda get zwraca domyślną wartość gdy brakuje klucza +pelen_slownik.get("one", 4) # => 1 +pelen_slownik.get("cztery", 4) # => 4 +# zauważ, że pelen_slownik.get("cztery") jest wciąż => None +# (get nie ustawia wartości słownika) + +# przypisz wartość do klucza podobnie jak w listach +pelen_slownik["cztery"] = 4 # teraz: pelen_slownik["cztery"] => 4 + +# "setdefault()" wstawia do słownika tylko jeśli nie było klucza +pelen_slownik.setdefault("piec", 5) # pelen_slownik["piec"] daje 5 +pelen_slownik.setdefault("piec", 6) # pelen_slownik["piec"] to wciąż 5 + + +# Teraz zbiory (set) ... cóż zbiory (to po prostu listy ale bez potórzeń) +pusty_zbior = set() +# Inicjalizujemy "set()" pewnymi wartościami +jakis_zbior = set([1, 2, 2, 3, 4]) # jakis_zbior to teraz set([1, 2, 3, 4]) + +# kolejność nie jest gwarantowana, nawet gdy wydaje się posortowane +inny_zbior = set([4, 3, 2, 2, 1]) # inny_zbior to set([1, 2, 3, 4]) + +# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru +pelen_zbior = {1, 2, 2, 3, 4} # => {1, 2, 3, 4} + +# Dodaj więcej elementów przez "add()" +pelen_zbior.add(5) # pelen_zbior is now {1, 2, 3, 4, 5} + +# Znajdź przecięcie zbiorów używając & +inny_zbior = {3, 4, 5, 6} +pelen_zbior & other_set # => {3, 4, 5} + +# Suma zbiorów | +pelen_zbior | other_set # => {1, 2, 3, 4, 5, 6} + +# Różnicę zbiorów da znak - +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Sprawdzanie obecności w zbiorze: "in". +2 in pelen_zbior # => True +10 in pelen_zbior # => False + + +#################################################### +## 3. Kontrola przepływu +#################################################### + +# Tworzymy zmienną some_var +some_var = 5 + +# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia są ważne Pythonie! +# wypisze "some_var jest mniejsza niż 10" +if some_var > 10: + print("some_var jest wieksza niż 10") +elif some_var < 10: # This elif clause is optional. + print("some_var jest mniejsza niż 10") +else: # This is optional too. + print("some_var jest równa 10") + + +""" +Pętla for iteruje po elementach listy wypisując: + pies to ssak + kot to ssak + mysz to ssak +""" +for zwierze in ["pies", "kot", "mysz"]: + # Możesz użyć % aby stworzyć sformatowane napisy + print("%s to ssak" % zwierze) + +""" +"range(liczba)" zwraca listę liczb +od zera do danej liczby: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +While to pętla która jest wykonywana dopóki spełniony jest warunek: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Skrót od x = x + 1 + +# Wyjątki wyłapujemy używając try, except + +# Działa w Pythonie 2.6 i wyższych: +try: + # Użyj "raise" aby wyrzucić wyjąte + raise IndexError("To błąd indeksu") +except IndexError as e: + pass # Pass to brak reakcji na błąd. Zazwyczaj nanosisz tu poprawki. +except (TypeError, NameError): + pass # kilka wyjątków może być przechwyce razem. +else: # Opcjonalna część bloku try/except. Musi wystąpić na końcu + print "Wszystko ok!" # Zadziała tylko, gdy program nie napotka wyjatku. + + +#################################################### +## 4. Funkcjie +#################################################### + +# Użyj "def" aby stworzyć nową funkcję +def dodaj(x, y): + print("x to %s a y to %s" % (x, y)) + return x + y # słówko kluczowe return zwraca wynik działania + +# Tak wywołuje się funkcję z parametrami (args): +dodaj(5, 6) # => wypisze "x to 5 a y to 6" i zwróci 11 + +# Innym sposobem jest wywołanie z parametrami nazwanymi. +dodaj(y=6, x=5) # tutaj kolejność podania nie ma znaczenia. + + +# Można też stworzyć funkcję, które przyjmują różną ilość parametrów +# nienazwanych args, co będzie interpretowane jako krotka jeśli nie użyjesz * +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1, 2, 3) + + +# Można też stworzyć funkcję, które przyjmują różną ilość parametrów +# nazwanych kwargs, które będa interpretowane jako słownik jeśli nie dasz ** +def keyword_args(**kwargs): + return kwargs + +# Wywołajmy to i sprawdźmy co się dzieje +keyword_args(wielka="stopa", loch="ness") # => {"wielka": "stopa", "loch": "ness"} + + +# Możesz też to pomieszać +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) wyrzuci: + (1, 2) + {"a": 3, "b": 4} +""" + +# Użyj * aby rozwinąć parametry z krotki args +# i użyj ** aby rozwinąć parametry nazwane ze słownika kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # odpowiednik foo(1, 2, 3, 4) +all_the_args(**kwargs) # odpowiednik foo(a=3, b=4) +all_the_args(*args, **kwargs) # odpowiednik foo(1, 2, 3, 4, a=3, b=4) + +# Możesz podać parametry args i kwargs do funkcji równocześnie +# przez rozwinięcie odpowiednio * i ** +def pass_all_the_args(*args, **kwargs): + all_the_args(*args, **kwargs) + print varargs(*args) + print keyword_args(**kwargs) + +# Zakres widoczności +x = 5 + +def setX(num): + # Lokalna zmienna x nie jest tym samym co zmienna x + x = num # => 43 + print x # => 43 + +def setGlobalX(num): + global x + print x # => 5 + x = num # globalna zmienna to teraz 6 + print x # => 6 + +setX(43) +setGlobalX(6) + +# Można tworzyć funkcje wewnętrzne i zwrócić je jako wynik +def rob_dodawacz(x): + def dodawacz(y): + return x + y + return dodawacz + +dodaj_10 = rob_dodawacz(10) +dodaj_10(3) # => 13 + +# Są również funkcje nienazwane "lambda" +(lambda x: x > 2)(3) # => True + +# Są także wbudowane funkcje wysokiego poziomu +map(add_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Można używać wyrażeń listowych do mapowania (map) i filtrowania (filter) +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + + +#################################################### +## 5. Klasy +#################################################### + +# Wszystkie klasy są podklasą object +class Czlowiek(object): + + # Atrybut klasy. Występuje we wszystkich instancjach klasy. + gatunek = "H. sapiens" + + # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji. + # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają + # obietky lub atrybuty, który żyją tylko w kontrolowanej przez + # użytkownika przestrzeni nazw. Nie używaj ich we własnych metodach. + def __init__(self, nazwa): + # przypisz parametr "nazwa" do atrybutu instancji + self.nazwa = nazwa + + # Metoda instancji. Wszystkie metody biorą "self" jako pierwszy argument + def mow(self, wiadomosc): + return "%s: %s" % (self.nazwa, wiadomosc) + + # Metoda klasowa współdzielona przez instancje. + # Ma wywołującą klasę jako pierwszy argument. + @classmethod + def daj_gatunek(cls): + return cls.gatunek + + # Metoda statyczna jest wywoływana bez argumentów klasy czy instancji. + @staticmethod + def grunt(): + return "*grunt*" + + +# Instancja klasy +i = Czlowiek(name="Ian") +print(i.mow("cześć")) # wypisze "Ian: cześć" + +j = Czlowiek("Joel") +print(j.mow("cześć")) # wypisze "Joel: cześć" + +# Wywołujemy naszą metodę klasową +i.daj_gatunek() # => "H. sapiens" + +# Zmieniamy wspólny parametr +Czlowiek.gatunek = "H. neanderthalensis" +i.daj_gatunek() # => "H. neanderthalensis" +j.daj_gatunek() # => "H. neanderthalensis" + +# Wywołanie metody statycznej +Czlowiek.grunt() # => "*grunt*" + + +#################################################### +## 6. Moduły +#################################################### + +# Tak importuje się moduły: +import math +print(math.sqrt(16)) # => 4 + +# Można podać konkretne funkcje, np. ceil, floor z modułu math +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# Można zaimportować wszystkie funkcje z danego modułu. +# Ostrzeżenie: nie jest to polecane. +from math import * + +# Można skracać nazwy modułów. +import math as m +math.sqrt(16) == m.sqrt(16) # => True +# sprawdźmy czy funkcje są równoważne +from math import sqrt +math.sqrt == m.sqrt == sqrt # => True + +# Moduły pythona to zwykłe skrypty napisane w tym języku. Możesz +# pisać własne i importować je. Nazwa modułu to nazwa pliku. + +# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu. +import math +dir(math) + + +#################################################### +## 7. Zaawansowane +#################################################### + +# Generatory pomagają tworzyć tzw. "leniwy kod" +def podwojne_liczby(iterowalne): + for i in iterowalne: + yield i + i + +# Generatory tworzą wartości w locie. +# W przeciwienstwie do wygenerowania wartości raz i ich zachowania, +# powstają one na bieżąco, w wyniku iteracji. To oznacza, że wartości +# większe niż 15 nie będą przetworzone w funkcji "podwojne_liczby". +# Zauważ, że xrange to generator, który wykonuje tę samą operację co range. +# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci, +# a xrange tworzy obiekt generatora zamiast tworzyć całą listę jak range. +# Użyto podkreślinika, aby odróżnić nazwę zmiennej od słówka kluczowego +# Pythona. +xrange_ = xrange(1, 900000000) + +# poniższa pętla będzie podwajać liczby aż do 30 +for i in podwojne_liczby(xrange_): + print(i) + if i >= 30: + break + + +# Dekoratory +# w tym przykładzie "beg" jest nakładką na "say" +# Beg wywołuje say. Jeśli say_please jest prawdziwe wtedy wzracana wartość +# zostanie zmieniona + +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Proszę! Jestem spłukany :(") + return msg + return wrapper + + +@beg +def say(say_please=False): + msg = "Kupisz mi piwo?" + return msg, say_please + + +print(say()) # Kupisz mi piwo? +print(say(say_please=True)) # Kupisz mi piwo? Proszę! Jestem spłukany :( +``` + +## Gotowy na więcej? +### Polskie + +* [Zanurkuj w Pythonie](http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie) +* [LearnPythonPl](http://www.learnpython.org/pl/) + +### Angielskie: +#### Darmowe źródła online + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +#### Inne + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/pogo.html.markdown b/pogo.html.markdown new file mode 100644 index 00000000..aa5d49f3 --- /dev/null +++ b/pogo.html.markdown @@ -0,0 +1,202 @@ +--- +language: pogoscript +contributors: + - ["Tim Macfarlane", "http://github.com/refractalize"] +filename: learnPogo.pogo +--- + +Pogoscript is a little language that emphasises readability, DSLs and provides excellent asynchronous primitives for writing connected JavaScript applications for the browser or server. + +``` javascript +// defining a variable +water temperature = 24 + +// re-assigning a variable after its definition +water temperature := 26 + +// functions allow their parameters to be placed anywhere +temperature at (a) altitude = 32 - a / 100 + +// longer functions are just indented +temperature at (a) altitude := + if (a < 0) + water temperature + else + 32 - a / 100 + +// calling a function +current temperature = temperature at 3200 altitude + +// this function constructs a new object with methods +position (x, y) = { + x = x + y = y + + distance from position (p) = + dx = self.x - p.x + dy = self.y - p.y + Math.sqrt (dx * dx + dy * dy) +} + +// `self` is similar to `this` in JavaScript with the +// exception that `self` isn't redefined in each new +// function definition +// `self` just does what you expect + +// calling methods +position (7, 2).distance from position (position (5, 1)) + +// as in JavaScript, objects are hashes too +position.'x' == position.x == position.('x') + +// arrays +positions = [ + position (1, 1) + position (1, 2) + position (1, 3) +] + +// indexing an array +positions.0.y + +n = 2 +positions.(n).y + +// strings +poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks. + Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon. + Put on my shirt and took it off in the sun walking the path to lunch. + A dandelion seed floats above the marsh grass with the mosquitos. + At 4 A.M. the two middleaged men sleeping together holding hands. + In the half-light of dawn a few birds warble under the Pleiades. + Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep + cheep cheep.' + +// that's Allen Ginsburg + +// interpolation +outlook = 'amazing!' +console.log "the weather tomorrow is going to be #(outlook)" + +// regular expressions +r/(\d+)m/i +r/(\d+) degrees/mg + +// operators +true @and true +false @or true +@not false +2 < 4 +2 >= 2 +2 > 1 + +// plus all the javascript ones + +// to define your own +(p1) plus (p2) = + position (p1.x + p2.x, p1.y + p2.y) + +// `plus` can be called as an operator +position (1, 1) @plus position (0, 2) +// or as a function +(position (1, 1)) plus (position (0, 2)) + +// explicit return +(x) times (y) = return (x * y) + +// new +now = @new Date () + +// functions can take named optional arguments +spark (position, color: 'black', velocity: {x = 0, y = 0}) = { + color = color + position = position + velocity = velocity +} + +red = spark (position 1 1, color: 'red') +fast black = spark (position 1 1, velocity: {x = 10, y = 0}) + +// functions can unsplat arguments too +log (messages, ...) = + console.log (messages, ...) + +// blocks are functions passed to other functions. +// This block takes two parameters, `spark` and `c`, +// the body of the block is the indented code after the +// function call + +render each @(spark) into canvas context @(c) + ctx.begin path () + ctx.stroke style = spark.color + ctx.arc ( + spark.position.x + canvas.width / 2 + spark.position.y + 3 + 0 + Math.PI * 2 + ) + ctx.stroke () + +// asynchronous calls + +// JavaScript both in the browser and on the server (with Node.js) +// makes heavy use of asynchronous IO with callbacks. Async IO is +// amazing for performance and making concurrency simple but it +// quickly gets complicated. +// Pogoscript has a few things to make async IO much much easier + +// Node.js includes the `fs` module for accessing the file system. +// Let's list the contents of a directory + +fs = require 'fs' +directory listing = fs.readdir! '.' + +// `fs.readdir()` is an asynchronous function, so we can call it +// using the `!` operator. The `!` operator allows you to call +// async functions with the same syntax and largely the same +// semantics as normal synchronous functions. Pogoscript rewrites +// it so that all subsequent code is placed in the callback function +// to `fs.readdir()`. + +// to catch asynchronous errors while calling asynchronous functions + +try + another directory listing = fs.readdir! 'a-missing-dir' +catch (ex) + console.log (ex) + +// in fact, if you don't use `try catch`, it will raise the error up the +// stack to the outer-most `try catch` or to the event loop, as you'd expect +// with non-async exceptions + +// all the other control structures work with asynchronous calls too +// here's `if else` +config = + if (fs.stat! 'config.json'.is file ()) + JSON.parse (fs.read file! 'config.json' 'utf-8') + else + { + color: 'red' + } + +// to run two asynchronous calls concurrently, use the `?` operator. +// The `?` operator returns a *future* which can be executed to +// wait for and obtain the result, again using the `!` operator + +// we don't wait for either of these calls to finish +a = fs.stat? 'a.txt' +b = fs.stat? 'b.txt' + +// now we wait for the calls to finish and print the results +console.log "size of a.txt is #(a!.size)" +console.log "size of b.txt is #(b!.size)" + +// futures in Pogoscript are analogous to Promises +``` + +That's it. + +Download [Node.js](http://nodejs.org/) and `npm install pogo`. + +There is plenty of documentation on [http://pogoscript.org/](http://pogoscript.org/), including a [cheat sheet](http://pogoscript.org/cheatsheet.html), a [guide](http://pogoscript.org/guide/), and how [Pogoscript translates to Javascript](http://featurist.github.io/pogo-examples/). Get in touch on the [google group](http://groups.google.com/group/pogoscript) if you have questions! diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown new file mode 100644 index 00000000..9e4b458d --- /dev/null +++ b/pt-br/brainfuck-pt.html.markdown @@ -0,0 +1,85 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["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, exceto no início de frases) é uma linguagem de +programação Turing-completa extremamente simples com apenas 8 comandos. + +``` +Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado. + +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 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). +. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A'). +, : Lê um único caractere para a célula atual. +[ : Se o valor da célula atual for zero, salta para o ] correspondente. + Caso contrário, passa para a instrução seguinte. +] : Se o valor da célula atual for zero, passa para a instrução seguinte. + Caso contrário, volta para a instrução relativa ao [ correspondente. + +[ e ] formam um ciclo while. Obviamente, devem ser equilibrados. + +Vamos ver alguns exemplos básicos em brainfuck: + +++++++ [ > ++++++++++ < - ] > +++++ . + +Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6. +A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se +o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10 +vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se +a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para +a célula #1 chegar a 0, momento em que se salta para o ] correspondente, +continuando com a instrução seguinte). + +Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2 +tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5 +vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor +65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal. + +, [ > + < - ] > . + +Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é +iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na +célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente +decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser +igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de +dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a +célula #2 e imprimimos o valor em ASCII. + +Os espaços servem apenas para tornar o programa mais legível. Podemos escrever +o mesmo programa da seguinte maneira: + +,[>+<-]>. + +Tente descobrir o que este programa faz: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Este programa lê dois números e os multiplica. + +Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um +ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados +para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula +#2, incrementando o valor da célula #3. Porém existe um problema, no final do +ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da +célula #4 é também incrementado e copiado para a célula #2. +``` + +E isto é brainfuck. Simples, não? Por divertimento você pode escrever os +seus próprios programas em brainfuck, ou então escrever um interpretador de +brainfuck em outra linguagem. O interpretador é relativamente fácil de se +implementar, mas caso você seja masoquista, tente escrever um interpretador de +brainfuck… em brainfuck. diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown new file mode 100644 index 00000000..61e267f5 --- /dev/null +++ b/pt-br/c++-pt.html.markdown @@ -0,0 +1,590 @@ +--- +language: c++ +filename: learncpp.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +C++ é uma linguagem de programação de sistemas que, +[de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +foi concebida para + +- ser um "C melhor" +- suportar abstração de dados +- suportar programação orientada a objetos +- suportar programação genérica + +Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais +recentes, C++ é amplamente utilizado porque compila para instruções nativas que +podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os +genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade +faz C++ uma das linguagens de programação mais utilizadas. + +```c++ +////////////////// +// Comparação com C +////////////////// + +// C ++ é quase um super conjunto de C e compartilha sua sintaxe básica para +// declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia +// em algumas das seguintes maneiras: + +// A função main() em C++ deve retornar um int, embora void main() é aceita +// pela maioria dos compiladores (gcc, bumbum, etc.) +// Este valor serve como o status de saída do programa. +// Veja http://en.wikipedia.org/wiki/Exit_status para mais informações. + +int main(int argc, char** argv) +{ + // Argumentos de linha de comando são passados em pelo argc e argv da mesma + // forma que eles estão em C. + // argc indica o número de argumentos, + // e argv é um array de strings, feito C (char*) representado os argumentos + // O primeiro argumento é o nome pelo qual o programa foi chamado. + // argc e argv pode ser omitido se você não se importa com argumentos, + // dando a assinatura da função de int main() + + // Uma saída de status de 0 indica sucesso. + return 0; +} + +// Em C++, caracteres literais são um byte. +sizeof('c') == 1 + +// Em C, caracteres literais são do mesmo tamanho que ints. +sizeof('c') == sizeof(10) + +// C++ tem prototipagem estrita +void func(); // função que não aceita argumentos + +// Em C +void func(); // função que pode aceitar qualquer número de argumentos + +// Use nullptr em vez de NULL em C++ +int* ip = nullptr; + +// Cabeçalhos padrão C estão disponíveis em C++, +// mas são prefixados com "c" e não têm sufixo .h + +#include <cstdio> + +int main() +{ + printf("Hello, world!\n"); + return 0; +} + +/////////////////////// +// Sobrecarga de função +/////////////////////// + +// C++ suporta sobrecarga de função +// desde que cada função tenha parâmetros diferentes. + +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("My int is %d", myInt); +} + +int main() +{ + print("Hello"); // Funciona para void print(const char*) + print(15); // Funciona para void print(int) +} + +///////////////////////////// +// Parâmetros padrão de função +///////////////////////////// + +// Você pode fornecer argumentos padrões para uma função se eles não são +// fornecidos pelo chamador. + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // Faça alguma coisa com os ints aqui +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Argumentos padrões devem estar no final da lista de argumentos. + +void invalidDeclaration(int a = 1, int b) // Erro! +{ +} + + +///////////// +// Namespaces (nome de espaços) +///////////// + +// Namespaces fornecem escopos distintos para variável, função e outras +// declarações. Namespaces podem estar aninhados. + +namespace First { + namespace Nested { + void foo() + { + printf("This is First::Nested::foo\n"); + } + } // Fim do namespace aninhado +} // Fim do namespace First + +namespace Second { + void foo() + { + printf("This is Second::foo\n") + } +} + +void foo() +{ + printf("This is global foo\n"); +} + +int main() +{ + // Assuma que tudo é do namespace "Second" a menos que especificado de + // outra forma. + using namespace Second; + + foo(); // imprime "This is Second::foo" + First::Nested::foo(); // imprime "This is First::Nested::foo" + ::foo(); // imprime "This is global foo" +} + +/////////////// +// Entrada/Saída +/////////////// + +// C ++ usa a entrada e saída de fluxos (streams) +// cin, cout, and cerr representa stdin, stdout, and stderr. +// << É o operador de inserção e >> é o operador de extração. + +#include <iostream> // Inclusão para o I/O streams + +using namespace std; // Streams estão no namespace std (biblioteca padrão) + +int main() +{ + int myInt; + + // Imprime na saída padrão (ou terminal/tela) + cout << "Enter your favorite number:\n"; + // Pega a entrada + cin >> myInt; + + // cout também pode ser formatado + cout << "Your favorite number is " << myInt << "\n"; + // imprime "Your favorite number is <myInt>" + + cerr << "Usado para mensagens de erro"; +} + +////////// +// Strings +////////// + +// Strings em C++ são objetos e têm muitas funções de membro +#include <string> + +using namespace std; // Strings também estão no namespace std (bib. padrão) + +string myString = "Hello"; +string myOtherString = " World"; + +// + é usado para concatenação. +cout << myString + myOtherString; // "Hello World" + +cout << myString + " You"; // "Hello You" + +// Em C++, strings são mutáveis e têm valores semânticos. +myString.append(" Dog"); +cout << myString; // "Hello Dog" + + +///////////// +// Referência +///////////// + +// Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de +// ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo. +// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário +// para _dereferencing_ e & (endereço de) não é usado para atribuição. + +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // Isso cria uma referência para foo. +fooRef += ". Hi!"; // Modifica foo através da referência +cout << fooRef; // Imprime "I am foo. Hi!" + +// Não realocar "fooRef". Este é o mesmo que "foo = bar", e foo == "I am bar" +// depois desta linha. + +fooRef = bar; + +const string& barRef = bar; // Cria uma referência const para bar. +// Como C, valores const (e ponteiros e referências) não podem ser modificado. +barRef += ". Hi!"; // Erro, referência const não pode ser modificada. + +////////////////////////////////////////// +// Classes e programação orientada a objeto +////////////////////////////////////////// + +// Primeiro exemplo de classes +#include <iostream> + +// Declara a classe. +// As classes são geralmente declarado no cabeçalho arquivos (.h ou .hpp). +class Dog { + // Variáveis de membro e funções são privadas por padrão. + std::string name; + int weight; + +// Todos os membros a seguir este são públicos até que "private:" ou +// "protected:" é encontrado. +public: + + // Construtor padrão + Dog(); + + // Declarações de função Membro (implementações a seguir) + // Note que usamos std :: string aqui em vez de colocar + // using namespace std; + // acima. + // Nunca coloque uma declaração "using namespace" em um cabeçalho. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Funções que não modificam o estado do objecto devem ser marcadas como + // const. Isso permite que você chamá-los se for dada uma referência const + // para o objeto. Além disso, observe as funções devem ser explicitamente + // declarados como _virtual_, a fim de ser substituídas em classes + // derivadas. As funções não são virtuais por padrão por razões de + // performance. + + virtual void print() const; + + // As funções também podem ser definidas no interior do corpo da classe. + // Funções definidas como tal são automaticamente embutidas. + void bark() const { std::cout << name << " barks!\n" } + + // Junto com os construtores, C++ fornece destruidores. + // Estes são chamados quando um objeto é excluído ou fica fora do escopo. + // Isto permite paradigmas poderosos, como RAII + // (veja abaixo) + // Destruidores devem ser virtual para permitir que as classes de ser + // derivada desta. + virtual ~Dog(); + +}; // Um ponto e vírgula deve seguir a definição de classe. + +// Funções membro da classe geralmente são implementados em arquivos .cpp. +void Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objetos (como strings) devem ser passados por referência +// se você pretende modificá-los, ou com const caso contrário. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Observe que "virtual" só é necessária na declaração, não a definição. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +void Dog::~Dog() +{ + cout << "Goodbye " << name << "\n"; +} + +int main() { + Dog myDog; // imprime "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.printDog(); // imprime "Dog is Barkley and weighs 10 kg" + return 0; +} // imprime "Goodbye Barkley" + +// herança: + +// Essa classe herda tudo público e protegido da classe Dog +class OwnedDog : public Dog { + + void setOwner(const std::string& dogsOwner) + + // Substituir o comportamento da função de impressão de todas OwnedDogs. + // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // Para uma introdução mais geral, se você não estiver familiarizado com o + // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se + // na verdade você está substituindo o método em uma classe base. + void print() const override; + +private: + std::string owner; +}; + +// Enquanto isso, no arquivo .cpp correspondente: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Chame a função de impressão na classe Dog base de + std::cout << "Dog is owned by " << owner << "\n"; + // Prints "Dog is <name> and weights <weight>" + // "Dog is owned by <owner>" +} + +////////////////////////////////////////// +// Inicialização e Sobrecarga de Operadores +////////////////////////////////////////// + +// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como +// +, -, *, /, etc. Isto é feito através da definição de uma função que é +// chamado sempre que o operador é usado. + +#include <iostream> +using namespace std; + +class Point { +public: + // Variáveis membro pode ser dado valores padrão desta maneira. + double x = 0; + double y = 0; + + // Define um construtor padrão que não faz nada + // mas inicializar o Point para o valor padrão (0, 0) + Point() { }; + + // A sintaxe a seguir é conhecido como uma lista de inicialização + // e é a maneira correta de inicializar os valores de membro de classe + Point (double a, double b) : + x(a), + y(b) + { /* Não fazer nada, exceto inicializar os valores */ } + + // Sobrecarrega o operador +. + Point operator+(const Point& rhs) const; + + // Sobrecarregar o operador +=. + Point& operator+=(const Point& rhs); + + // Ele também faria sentido para adicionar os operadores - e -=, + // mas vamos pular para sermos breves. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Criar um novo ponto que é a soma de um e rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // Isto chama que o operador ponto + + // Ressalte-se a chamadas (função)+ com direito como seu parâmetro... + Point result = up + right; + // Imprime "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +///////////////////////// +// Tratamento de Exceções +///////////////////////// + +// A biblioteca padrão fornece alguns tipos de exceção +// (see http://en.cppreference.com/w/cpp/error/exception) +// mas qualquer tipo pode ser jogado como uma exceção +#include <exception> + +// Todas as exceções lançadas dentro do bloco try pode ser capturado por +// manipuladores de captura subseqüentes +try { + // Não aloca exceções no heap usando _new_. + throw std::exception("A problem occurred"); +} +// Capturar exceções por referência const se eles são objetos +catch (const std::exception& ex) +{ + std::cout << ex.what(); +// Captura qualquer exceção não capturada pelos blocos _catch_ anteriores +} catch (...) +{ + std::cout << "Exceção desconhecida encontrada"; + throw; // Re-lança a exceção +} + +/////// +// RAII +/////// + +// RAII significa alocação de recursos é de inicialização. +// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o +// conceito simples que um construtor para um objeto adquire recursos daquele +// objeto e o destruidor liberá-los. + +// Para entender como isso é útil, +// Considere uma função que usa um identificador de arquivo C: +void doSomethingWithAFile(const char* filename) +{ + // Para começar, assuma que nada pode falhar. + + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura. + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Feche o arquivo. +} + +// Infelizmente, as coisas são levemente complicadas para tratamento de erros. +// Suponha que fopen pode falhar, e que doSomethingWithTheFile e +// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As +// exceções são a forma preferida de lidar com o fracasso, mas alguns +// programadores, especialmente aqueles com um conhecimento em C, discordam +// sobre a utilidade de exceções). Agora temos que verificar cada chamada para +// o fracasso e fechar o identificador de arquivo se ocorreu um problema. + +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura + if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha. + reuturn false; // Relate o fracasso para o chamador. + + // Suponha cada função retorne false, se falhar + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return false; // Propague o erro. + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return false; // Propague o erro. + } + + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return true; // Indica sucesso +} + +// Programadores C frequentemente limpam isso um pouco usando Goto: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + reuturn false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Close the file + return true; // Indica sucesso + +failure: + fclose(fh); + return false; // Propague o erro. +} + +// Se as funções indicam erros usando exceções, +// as coisas são um pouco mais limpo, mas ainda abaixo do ideal. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura. + if (fh == nullptr) + throw std::exception("Não pode abrir o arquivo."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Certifique-se de fechar o arquivo se ocorrer um erro. + throw; // Em seguida, re-lance a exceção. + } + + fclose(fh); // Feche o arquivo + // Tudo ocorreu com sucesso! +} + +// Compare isso com o uso de C++ classe fluxo de arquivo (fstream) fstream usa +// seu destruidor para fechar o arquivo. Lembre-se de cima que destruidores são +// automaticamente chamado sempre que um objeto cai fora do âmbito. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream é curto para o fluxo de arquivo de entrada + std::ifstream fh(filename); // Abra o arquivo + + // faça alguma coisa com o arquivo + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // O arquivo é automaticamente fechado aqui pelo destructor + +// Isto tem _grandes_ vantagens: +// 1. Não importa o que aconteça, +// o recurso (neste caso, o identificador de ficheiro) irá ser limpo. +// Depois de escrever o destruidor corretamente, +// É _impossível_ esquecer de fechar e vazar o recurso +// 2. Nota-se que o código é muito mais limpo. +// As alças destructor fecham o arquivo por trás das cenas +// sem que você precise se preocupar com isso. +// 3. O código é seguro de exceção. +// Uma exceção pode ser jogado em qualquer lugar na função e a limpeza +// irá ainda ocorrer. + +// Todos códigos C++ usam RAII extensivamente para todos os recursos. +// Outros exemplos incluem +// - Memória usa unique_ptr e shared_ptr +// - Contentores - a lista da biblioteca ligada padrão, +// vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante +// tudo é automaticamente destruído quando eles saem de escopo +// - Mutex usa lock_guard e unique_lock +``` +Leitura Adicional: + +Uma referência atualizada da linguagem pode ser encontrada em +<http://cppreference.com/w/cpp> + +Uma fonte adicional pode ser encontrada em <http://cplusplus.com> diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown new file mode 100644 index 00000000..451df4f3 --- /dev/null +++ b/pt-br/c-pt.html.markdown @@ -0,0 +1,649 @@ +--- +language: c +filename: learnc.c +contributors: + - ["Adam Bard", "http://adambard.com/"] + - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] +translators: + - ["João Farias", "https://github.com/JoaoGFarias"] +lang: pt-br +filename: c-pt.el +--- + +Ah, C. Ainda é **a** linguagem de computação de alta performance. + +C é a liguangem de mais baixo nível que a maioria dos programadores +irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique +antento que este manual de gerenciamento de memória e C vai levanter-te +tão longe quanto você precisa. + +```c +// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99 + +/* +Comentários de multiplas linhas se parecem com este. +Funcionam no C89 também. +*/ + +// Constantes: #define <palavra-chave> +#definie DAY_IN_YEAR 365 + +//enumarações também são modos de definir constantes. +enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB}; +// SEG recebe 2 automaticamente, TER recebe 3, etc. + +// Cabeçalhos são inclusos com #include +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// (Nomes dos arquivos entre <colchetes> são cabeçalhos para bibliotecas padrão de C.) +// Para cabeçalhos próprios, use aspas ao invés de colchetes: +#include "minha_biblioteca.h" + +// Declare assinaturas das funções no início do arquivo .h ou no topo +// do seu arquivo .c. +void funcao_1(char c); +int funcao_2(void); + +// Deve-se declarar um 'protótipo de função' antes do main() quando as ocorrências +// dessas funções estão após sua função main() +int soma_dois_ints(int x1, int x2); // protótipo de função + +// O ponto de entrada do teu programa é uma função +// chamada main, com tipo de retorno inteiro +int main() { + // Usa-se printf para escrever na tela, + // para "saída formatada" + // %d é um inteiro, \n é uma nova linha + printf("%d\n", 0); // => Imprime 0 + // Todos as declarações devem acabar com + // ponto e vírgula + + /////////////////////////////////////// + // Tipos + /////////////////////////////////////// + + // ints normalmente tem 4 bytes + int x_int = 0; + + // shorts normalmente tem 2 bytes + short x_short = 0; + + // chars sempre tem um byte + char x_char = 0; + char y_char = 'y'; // Literais de caracter são cercados por ' + + // longs tem entre 4 e 8 bytes; longs long tem garantia + // de ter pelo menos 64 bits + long x_long = 0; + long long x_long_long = 0; + + // floats são normalmente números de ponto flutuante + // com 32 bits + float x_float = 0.0; + + // doubles são normalmente números de ponto flutuante + // com 64 bits + double x_double = 0.0; + + // Tipos inteiros podem ser sem sinal. + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // caracteres dentro de aspas simples são inteiros + // no conjunto de caracteres da máquina. + '0' // => 48 na tabela ASCII. + 'A' // => 65 na tabela ASCII. + + // sizeof(T) devolve o tamanho de uma variável do tipo T em bytes + // sizeof(obj) devolve o tamanho de uma expressão (variável, literal, etc.). + printf("%zu\n", sizeof(int)); // => 4 (na maioria das máquinas com palavras de 4 bytes) + + // Se o argumento do operador `sizeof` é uma expressão, então seus argumentos + // não são avaliados (exceto em VLAs (veja abaixo)). + // O valor devolve, neste caso, é uma constante de tempo de compilação. + int a = 1; + // size_t é um inteiro sem sinal com pelo menos 2 bytes que representa + // o tamanho de um objeto. + size_t size = sizeof(a++); // a++ não é avaliada. + printf("sizeof(a++) = %zu where a = %d\n", size, a); + // imprime "sizeof(a++) = 4 onde a = 1" (quando em uma arquitetura de 32 bits) + + // Arrays precisam ser inicializados com um tamanho concreto + char meu_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes + int meu_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes + // (assumindo palavras de 4 bytes) + + // Você pode inicializar um array com 0 desta forma: + char meu_array[20] = {0}; + + // Indexar um array é semelhante a outras linguages + // Melhor dizendo, outras linguagens são semelhantes a C + meu_array[0]; // => 0 + + // Array são mutáveis; são apenas memória! + meu_array[1] = 2; + printf("%d\n", meu_array[1]); // => 2 + + // No C99 (e como uma features opcional em C11), arrays de tamanho variável + // VLA (do inglês), podem ser declarados também. O tamanho destes arrays + // não precisam ser uma constante de tempo de compilação: + printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho + char buf[0x100]; + fgets(buf, sizeof buf, stdin); + + // strtoul transforma a string em um inteiro sem sinal + size_t size = strtoul(buf, NULL, 10); + int var_length_array[size]; // declara o VLA + printf("sizeof array = %zu\n", sizeof var_length_array); + + //Uma possível saída para esse programa seria: + // > Entre o tamanho do array:: 10 + // > sizeof array = 40 + + // String são apenas arrays de caracteres terminados por um + // byte NUL (0x00), representado em string pelo caracter especial '\0'. + // (Não precisamos incluir o byte NUL em literais de string; o compilador + // o insere ao final do array para nós.) + char uma_string[20] = "Isto é uma string"; + // Observe que 'é' não está na tabela ASCII + // A string vai ser salva, mas a saída vai ser estranha + // Porém, comentários podem conter acentos + printf("%s\n", uma_string); // %s formata a string + + printf("%d\n", uma_string[16]); // => 0 + // i.e., byte #17 é 0 (assim como 18, 19, e 20) + + // Se temos caracteres entre aspas simples, temos um caracter literal. + // Seu tipo é `int`, *não* `char` (por razões históricas). + int cha = 'a'; // ok + char chb = 'a'; // ok também (conversão implícita de int para char) + + // Arrays multi-dimensionais: + int multi_array[2][5] = { + {1, 2, 3, 4, 5}, + {6, 7, 8, 9, 0} + }; + // Acesso a elementos: + int array_int = multi_array[0][2]; // => 3 + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + + // Atalho para multiplas declarações: + int i1 = 1, i2 = 2; + float f1 = 1.0, f2 = 2.0; + + int a, b, c; + a = b = c = 0; + + // Aritimética é óbvia + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5, porém, é truncado para 0) + + f1 / f2; // => 0.5, mais ou menos epsilon + // Números e cálculos de ponto flutuante não são exatos + + // Modulo também existe + 11 % 3; // => 2 + + // Operadores de comparação provavelmente são familiares, + // porém não há tipo booleano em C. Usa-se ints no lugar. + // (Ou _Bool or bool em C99.) + // 0 é falso e qualquer outra coisa é verdadeiro + // (Os operadores de comparação devolvem 0 ou 1.) + // Comparison operators are probably familiar, but + 3 == 2; // => 0 (falso) + 3 != 2; // => 1 (verdadeiro) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C não é Python - comparações não se encadeam. + int a = 1; + // Errado: + int entre_0_e_2 = 0 < a < 2; + // Correto: + int entre_0_e_2 = 0 < a && a < 2; + + // Lógica funciona sobre ints + !3; // => 0 (Não lógico) + !0; // => 1 + 1 && 1; // => 1 (E lógico) + 0 && 1; // => 0 + 0 || 1; // => 1 (Ou lógico) + 0 || 0; // => 0 + + //Expressão condicional ( ? : ) + int a = 5; + int b = 10; + int z; + z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." + + //Operadores de incremento e decremento: + char *s = "iLoveC"; + int j = 0; + s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j. + j = 0; + s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s. + // o mesmo com j-- e --j + + // Operadores bit a bit! + ~0x0F; // => 0xF0 (negação bit a bit, "complemento de 1") + 0x0F & 0xF0; // => 0x00 (bit a bit E) + 0x0F | 0xF0; // => 0xFF (bit a bit OU) + 0x04 ^ 0x0F; // => 0x0B (bit a bit OU EXCLUSIVO) + 0x01 << 1; // => 0x02 (bit a bit shift para esquerda (por 1)) + 0x02 >> 1; // => 0x01 (bit a bit shift para direita (por 1)) + + // Cuidado quando fizer shift em inteiro com sinal - o seguinte é indefinido: + // - Fazer shift sobre um bit de sinal de um inteiro com sinal (int a = 1 << 32) + // - Fazer shift a esquerda sobre um número negativo (int a = -1 << 2) + // - Fazer shift maior que a largura do tipo de LHS: + // int a = 1 << 32; // Indefinido se int é de tamanho 32 bits + + /////////////////////////////////////// + // Estruturas de Controle + /////////////////////////////////////// + + if (0) { + printf("Nunca rodará\n"); + } else if (0) { + printf("Também nunca rodará\n"); + } else { + printf("Eu serei impresso\n"); + } + + // Loops while existem + int ii = 0; + while (ii < 10) { //QUALQUER valor diferente de 0 é verdadeiro + printf("%d, ", ii++); // ii++ incrementa o valor de ii APÓS usá-lo + } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + int kk = 0; + do { + printf("%d, ", kk); + } while (++kk < 10); // ++kk incrementa o valor de kk ANTES de usá-lo + // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Loops for também + int jj; + for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); + } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // *****NOTAS*****: + // Loops e Funções PRECISAM ter um corpo. Se nenhum corpo é necessário: + int i; + for (i = 0; i <= 5; i++) { + ; // Use ponto e vírgula para agir como um corpo (declaração nula) + } + + // Criando branchs com escolhas múltiplas: switch() + switch (alguma_expressao_integral) { + case 0: // labels precisam ser expressões integrais **constantes** + faca_algo(); + break; // Sem break, o controle continua após a label + case 1: + faca_outra_coisa(); + break; + default: + // Se `alguma_expressao_integral` não coincidir com nenhuma label + fputs("erro!\n", stderr); + exit(-1); + break; + } + + + /////////////////////////////////////// + // Cast de tipos + /////////////////////////////////////// + + // Todo valor em C tem um tipo, mas você pode fazer um cast de um valor em outro tipo + // se você quiser (com algumas restrições). + + int x_hex = 0x01; // Você pode colocar valores hexadecimais em variáveis + + // Cast entre tipos tentará preservar seus valores numéricos + printf("%d\n", x_hex); // => Imprime 1 + printf("%d\n", (short) x_hex); // => Imprime 1 + printf("%d\n", (char) x_hex); // => Imprime 1 + + // Tipos irão ter overflow sem aviso + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits) + + // Para determinar o valor máximo de um `char`, de um `signed char` e de + // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX + // e UCHAR_MAX de <limits.h> + + // Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa. + printf("%f\n", (float)100); // %f formata um float + printf("%lf\n", (double)100); // %lf formata um double + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // Ponteiros + /////////////////////////////////////// + + // Um ponteiro é uma variável declarada para armazenar um endereço de memória. + // Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você + // Pode usar o endereço de memória de suas variáveis, então, brincar com eles. + + int x = 0; + printf("%p\n", (void *)&x); // Use & para usar o endereço de uma variável + // (%p formata um objeto ponteiro do tipo void *) + // => Imprime algum endereço de memória; + + // Ponteiros começam com * na sua declaração + int *px, nao_eh_um_ponteiro; // px é um ponteiro para um int + px = &x; // armazena o endereço de x em px + printf("%p\n", (void *)px); // => Imprime algum endereço de memória + printf("%zu, %zu\n", sizeof(px), sizeof(nao_eh_um_ponteiro)); + // => Imprime "8, 4" em um sistema típico de 64 bits + + // Para pegar um valor no endereço apontado por um ponteiro, + // coloque * na frente para de-referenciá-lo. + // Nota: sim, é confuso usar '*' _tanto_ para declaração de ponteiro + // como para de-referenciá-lo. + printf("%d\n", *px); // => Imprime 0, o valor de x + + // Você também pode mudar o valor que o ponteiro está apontando. + // Teremo que cercar a de-referência entre parenteses, pois + // ++ tem uma precedência maior que *. + (*px)++; // Incrementa o valor que px está apontando por 1 + printf("%d\n", *px); // => Imprime 1 + printf("%d\n", x); // => Imprime 1 + + // Arrays são um boa maneira de alocar um bloco contínuo de memória + int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho + int xx; + for (xx = 0; xx < 20; xx++) { + x_array[xx] = 20 - xx; + } //Inicializa x_array com 20, 19, 18,... 2, 1 + + // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array + int* x_ptr = x_array; + // x_ptr agora aponta para o primeiro elemento do array (o inteiro 20). + // Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos. + // Por exemplo, quando um array é passado para uma função ou é atribuído a um + // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro. + // Exceções: quando o array é o argumento de um operador `&` (endereço-de): + // Exceptions: when the array is the argument of the `&` (address-of) operator: + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`! + // É do tipo "ponteiro para array" (de `int`s). + // ou quando o array é uma string literal usada para inicializar um array de char: + char arr[] = "foobarbazquirk"; + // ou quando é um argumento dos operadores `sizeof` ou `alignof`: + int arr[10]; + int *ptr = arr; // equivalente a int *ptr = &arr[0]; + printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8" + + // Ponteiros podem ser incrementados ou decrementados baseado no seu tipo + // (isto é chamado aritimética de ponteiros + printf("%d\n", *(x_ptr + 1)); // => Imprime 19 + printf("%d\n", x_array[1]); // => Imprime 19 + + // Você também pode alocar dinamicamente blocos de memória com a função + // da biblioteca padrão malloc, a qual recebe um argumento do tipo size_t + // representando o número de bytes a ser alocado (geralmente da heap, apesar de + // isto poder não ser verdadeiro em, e.g., sistemas embarcados - o C padrão diz + // nada sobre isso). + int *my_ptr = malloc(sizeof(*my_ptr) * 20); + for (xx = 0; xx < 20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx + } //Inicializa a memória com 20, 19, 18, 17... 2, 1 (como ints) + + // Dereferenciar memória que você não alocou cria + // "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido" + printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa. + + // Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo, + // ou ninguém mais será capaz de usá-lo até o fim da execução + // (Isto cham-se "memory leak"): + free(my_ptr); + + // Strings são arrays de char, mas elas geralmente são representadas + // como um ponteiro para char (com o apontador para o primeiro elemento do array). + // É boa prática usar `const char *' quando de-referenciando uma literal string, + // dado que elas não deverão ser modificadas (i.e. "foo"[0] = 'a' é ILEGAL.) + const char *my_str = "Esta é a minha literal string"; + printf("%c\n", *my_str); // => 'T' + + // Este não é o caso se a string for um array + // (potencialmente inicializado com um literal string) + // que reside em uma memória de escrita, como em: + char foo[] = "foo"; + foo[0] = 'a'; // Isto é legal, foo agora contém "aoo" + + funcao_1(); +} // fim da função main + +/////////////////////////////////////// +// Funções +/////////////////////////////////////// + +//Sintaxe de declaração de funções: +// <tipo de retorno> <nome da função>(<argumentos>) + +int soma_dois_int(int x1, int x2) +{ + return x1 + x2; // Use return para retornar um valor +} + +/* +Funções são chamadas por valor. Quando uma função é chamada, os argumentos passados +para a função são cópias dos argumento originais (a não ser arrays). Qualquer coisa +que você faz nos argumentos de uma função não alteram o valor do argumento original +onde a função foi chamada. + +Use ponteiros se você precisa alterar os valores dos argumentos originais + +Exemplo: reversão de string in-place +*/ + +// Uma função void não retorna valor algum +void str_reverse(char *str_in) +{ + char tmp; + int ii = 0; + size_t len = strlen(str_in); // `strlen()` é parte da biblioteca padrão C + for (ii = 0; ii < len / 2; ii++) { + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // iiº char do final + str_in[len - ii - 1] = tmp; + } +} + +/* +char c[] = "Isto é um teste."; +str_reverse(c); +printf("%s\n", c); // => ".etset mu é otsI" +*/ + +// Se estiver referenciando variáveis externas à função, use a palavra-chave extern. +int i = 0; +void testFunc() { + extern int i; //i aqui agora está usando a variável externa +} + +// Faça variáveis externas privadas para o código-fonte com static: +static int i = 0; // Outros arquivos usando testFunc() não podem acessar a variável i +void testFunc() { + extern int i; +} +//**Você pode declarar funções como static para torná-las privadas** + + +/////////////////////////////////////// +// Tipos definidos pelo usuário e structs +/////////////////////////////////////// + +// Typedefs podem ser usadas para criar apelidos para tipos +typedef int meu_tipo; +meu_tipo var_meu_tipo = 0; + +// Structs são apenas coleções de dados, os membros são alocados sequencialmente, +// na ordem que são escritos: +struct retangulo { + int altura; + int largura; +}; + +// Geralmente não é verdade que +// sizeof(struct retangulo) == sizeof(int) + sizeof(int) +// devido ao potencial de preenchimento entre os membros da estrutura +// (isto é por razões de alinhamento). [1] + +void funcao_1() +{ + struct retangulo meu_retan; + + // Acesse os membros da estrutura com . + meu_retan.altura = 10; + meu_retan.largura = 20; + + // Você pode declarar ponteiros para structs + struct retangulo *meu_retan_ptr = &meu_retan; + + // Use de-referenciamento para setar os membros da + // struct apontada... + (*meu_retan_ptr).altura = 30; + + // ... ou ainda melhor: prefira usar o atalho -> para melhorar legibilidade + meu_retan_ptr->largura = 10; // O mesmo que (*meu_retan_ptr).largura = 10; +} + +//Você pode aplicar um typedef para uma struct por conveniência +typedef struct retangulo retan; + +int area(retan r) +{ + return r.largura * r.altura; +} + +// Se você tiver structus grande, você pode passá-las "por ponteiro" +// para evitar cópia de toda a struct: +int area(const retan *r) +{ + return r->largura * r->altura; +} + +/////////////////////////////////////// +// Ponteiros para funções +/////////////////////////////////////// +/* +Em tempo de execução, funções são localizadas em endereços de memória +conhecidos. Ponteiros para funções são como qualquer outro ponteiro +(apenas guardam endereços de memória), mas podem ser usados para invocar funções +diretamente e passá-las para por toda parte. +Entretanto, a sintaxe de definição por ser um pouco confusa. + +Exemplo: use str_reverso através de um ponteiro +*/ +void str_reverso_através_ponteiro(char *str_entrada) { + // Define uma variável de ponteiro para função, nomeada f. + void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo. + f = &str_reverso; //Atribue o endereço da função em si (determinado em tempo de execução. + // f = str_reverso; Também funciona - função tornam-se ponteiros, assim como arrays + (*f)(str_entrada); // Chamando a função através do ponteiro + // f(str_entrada); // Esta é uma sintaxe alternativa, mas equivalente. +} + +/* +Desde que as assinaturas das funções sejam compatíveis, você pode atribuir qualquer +função ao mesmo ponteiro. Ponteiros para funções são geralmente um typedef por +simplicidade e legibilidade, como segue: +*/ + +typedef void (*minha_função_type)(char *); + +// Declarando o ponteiro: +// ... +// minha_função_type f; + +//Caracteres especiais: +'\a' // Alerta (sino) +'\n' // Nova linha +'\t' // Tab (justifica texto a esquerda) +'\v' // Tab vertical +'\f' // Nova linha (formfeed) +'\r' // Retorno de carroça +'\b' // Backspace +'\0' // Caracter nulo. Geralmente colocado ao final de string em C. + // oi\n\0. \0 é usado por convenção para marcar o fim da string. +'\\' // Barra invertida +'\?' // Interrogação +'\'' // Aspas simples +'\"' // Aspas duplas +'\xhh' // Número hexadecimal. Exemplo: '\xb' = tab vertical +'\ooo' // Número octal. Exemplo: '\013' = tab vertical + +// formatando impressão: +"%d" // inteiro +"%3d" // inteiro com pelo menos 3 dígitos (justifica texto a direita) +"%s" // string +"%f" // ponto-flutuante +"%ld" // long +"%3.2f" // ponto-flutuante com pelo menos 3 dígitos a esquerda e 2 a direita +"%7.4s" // (também pode-se fazer com strings) +"%c" // char +"%p" // ponteiro +"%x" // hexadecimal +"%o" // octal +"%%" // imprime % + +/////////////////////////////////////// +// Ordem de avaliação +/////////////////////////////////////// + +//-----------------------------------------------------------// +// Operadores | Associatividade // +//-----------------------------------------------------------// +// () [] -> . | esquerda para direita // +// ! ~ ++ -- + = *(type)sizeof | direita para esqureda // +// * / % | esquerda para direita // +// + - | esquerda para direita // +// << >> | esquerda para direita // +// < <= > >= | esquerda para direita // +// == != | esquerda para direita // +// & | esquerda para direita // +// ^ | esquerda para direita // +// | | esquerda para direita // +// && | esquerda para direita // +// || | esquerda para direita // +// ?: | direita para esqureda // +// = += -= *= /= %= &= ^= |= <<= >>= | direita para esqureda // +// , | esquerda para direita // +//-----------------------------------------------------------// + +``` + +## Leitura adicional + +É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language). +Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem, +ideias que não são consideradas boas hoje) ou práticas mudadas. + +Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/). + +Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com). + +É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral. +Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja +[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle). + +Além disso, Google é teu amigo. +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown new file mode 100644 index 00000000..7e8b3f7b --- /dev/null +++ b/pt-br/clojure-pt.html.markdown @@ -0,0 +1,384 @@ +--- +language: clojure +filename: learnclojure-pt.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"] +lang: pt-br +--- + +Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversas utilidades [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado a medida que isso se torna necessário. + +Essa combinação permite gerenciar processamento concorrente de maneira muito simples, e frequentemente de maneira automática. + +(Sua versão de clojure precisa ser pelo menos 1.2) + + +```clojure +; Comentários começam por ponto e vírgula + +; Clojure é escrito em "forms", os quais são simplesmente +; listas de coisas dentro de parênteses, separados por espaços em branco. + +; O "reader" (leitor) de Clojure presume que o primeiro elemento de +; uma par de parênteses é uma função ou macro, e que os resto são argumentos. + +: A primeira chamada de um arquivo deve ser ns, para configurar o namespace (espaço de nomes) +(ns learnclojure) + +; Alguns exemplos básicos: + +; str cria uma string concatenando seus argumentos +(str "Hello" " " "World") ; => "Hello World" + +; Cálculos são feitos de forma direta e intuitiva +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; Você pode comparar igualdade utilizando = +(= 1 1) ; => true +(= 2 1) ; => false + +; Negação para operações lógicas +(not true) ; => false + +; Aninhar "forms" funciona como esperado +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; Tipos +;;;;;;;;;;;;; + +; Clojure usa os tipos de objetos de Java para booleanos, strings e números. +; Use `class` para inspecioná-los +(class 1) ; Literais Integer são java.lang.Long por padrão +(class 1.); Literais Float são java.lang.Double +(class ""); Strings são sempre com aspas duplas, e são java.lang.String +(class false) ; Booleanos são java.lang.Boolean +(class nil); O valor "null" é chamado nil + +; Se você quiser criar um lista de literais, use aspa simples para +; ela não ser avaliada +'(+ 1 2) ; => (+ 1 2) +; (que é uma abreviação de (quote (+ 1 2))) + +; É possível avaliar uma lista com aspa simples +(eval '(+ 1 2)) ; => 3 + +; Coleções e sequências +;;;;;;;;;;;;;;;;;;; + +; Listas são estruturas encadeadas, enquanto vetores são implementados como arrays. +; Listas e Vetores são classes Java também! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; Uma lista é escrita como (1 2 3), mas temos que colocar a aspa +; simples para impedir o leitor (reader) de pensar que é uma função. +; Também, (list 1 2 3) é o mesmo que '(1 2 3) + +; "Coleções" são apenas grupos de dados +; Listas e vetores são ambos coleções: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; "Sequências" (seqs) são descrições abstratas de listas de dados. +; Apenas listas são seqs. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; Um seq precisa apenas prover uma entrada quando é acessada. +; Portanto, já que seqs podem ser avaliadas sob demanda (lazy) -- elas podem definir séries infinitas: +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (uma série infinita) +(take 4 (range)) ; (0 1 2 3) + +; Use cons para adicionar um item no início de uma lista ou vetor +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; Conj adiciona um item em uma coleção sempre do jeito mais eficiente. +; Para listas, elas inserem no início. Para vetores, é inserido no final. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; Use concat para concatenar listas e vetores +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; Use filter, map para interagir com coleções +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; Use reduce para reduzi-los +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; Reduce pode receber um argumento para o valor inicial +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; Funções +;;;;;;;;;;;;;;;;;;;;; + +; Use fn para criar novas funções. Uma função sempre retorna +; sua última expressão. +(fn [] "Hello World") ; => fn + +; (É necessário colocar parênteses para chamá-los) +((fn [] "Hello World")) ; => "Hello World" + +; Você pode atribuir valores a variáveis utilizando def +(def x 1) +x ; => 1 + +; Atribua uma função para uma var +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; Você pode abreviar esse processo usando defn +(defn hello-world [] "Hello World") + +; O [] é uma lista de argumentos para um função. +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; Você pode ainda usar essa abreviação para criar funcões: +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; Vocé pode ter funções multi-variadic, isto é, com um número variável de argumentos +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; Funções podem agrupar argumentos extras em uma seq +(defn count-args [& args] + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" + +; Você pode misturar argumentos regulares e argumentos em seq +(defn hello-count [name & args] + (str "Hello " name ", you passed " (count args) " extra args")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" + + +; Mapas +;;;;;;;;;; + +; Hash maps e array maps compartilham uma mesma interface. Hash maps são mais +; rápidos para pesquisa mas não mantém a ordem da chave. +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; Arraymaps pode automaticamente se tornar hashmaps através da maioria das +; operações se eles ficarem grandes o suficiente, portanto não há necessida de +; se preocupar com isso. + +;Mapas podem usar qualquer valor que se pode derivar um hash como chave + + +; Mapas podem usar qualquer valor em que se pode derivar um hash como chave, +; mas normalmente palavras-chave (keywords) são melhores. +; Keywords são como strings mas com algumas vantagens. +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; A propósito, vírgulas são sempre tratadas como espaçoes em branco e não fazem nada. + +; Recupere o valor de um mapa chamando ele como uma função +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; Uma palavra-chave pode ser usada pra recuperar os valores de um mapa +(:b keymap) ; => 2 + +; Não tente isso com strings +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; Buscar uma chave não presente retorna nil +(stringmap "d") ; => nil + +; Use assoc para adicionar novas chaves para hash-maps +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; Mas lembre-se, tipos em Clojure são sempre imutáveis! +keymap ; => {:a 1, :b 2, :c 3} + +; Use dissoc para remover chaves +(dissoc keymap :a :b) ; => {:c 3} + +; Conjuntos +;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; Adicione um membro com conj +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; Remova um membro com disj +(disj #{1 2 3} 1) ; => #{2 3} + +; Test por existência usando set como função: +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; Existem muitas outras funções no namespace clojure.sets + +; Forms úteis +;;;;;;;;;;;;;;;;; + +; Construções lógicas em Clojure são como macros, e +; se parecem com as demais +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; Use let para criar um novo escopo associando sîmbolos a valores (bindings) +(let [a 1 b 2] + (> a b)) ; => false + +; Agrupe comandos juntos com "do" +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; Funções tem um do implícito +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; Assim como let +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; Módulos +;;;;;;;;;;;;;;; + +; Use "use" para poder usar todas as funções de um modulo +(use 'clojure.set) + +; Agora nós podemos usar operações com conjuntos +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; Você pode escolher um subconjunto de funções para importar +(use '[clojure.set :only [intersection]]) + +; Use require para importar um módulo +(require 'clojure.string) + +; Use / para chamar funções de um módulo +; Aqui, o módulo é clojure.string e a função é blank? +(clojure.string/blank? "") ; => true + +; Você pode dar para um módulo um nome mais curto no import +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (#"" denota uma expressão regular literal) + +; Você pode usar require (e até "use", mas escolha require) de um namespace utilizando :require. +; Não é necessário usar aspa simples nos seus módulos se você usar desse jeito. +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java tem uma biblioteca padrão enorme e muito útil, +; portanto é importante aprender como utiliza-la. + +; Use import para carregar um modulo java +(import java.util.Date) + +; Você pode importar usando ns também. +(ns test + (:import java.util.Date + java.util.Calendar)) + +; Use o nome da clase com um "." no final para criar uma nova instância +(Date.) ; <a date object> + +; Use . para chamar métodos. Ou, use o atalho ".method" +(. (Date.) getTime) ; <a timestamp> +(.getTime (Date.)) ; exatamente a mesma coisa. + +; Use / para chamar métodos estáticos +(System/currentTimeMillis) ; <a timestamp> (o módulo System está sempre presente) + +; Use doto para pode lidar com classe (mutáveis) de forma mais tolerável +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; Software Transactional Memory é o mecanismo que Clojure usa para gerenciar +; estado persistente. Tem algumas construções em Clojure que o utilizam. + +; O atom é o mais simples. Passe pra ele um valor inicial +(def my-atom (atom {})) + +; Atualize o atom com um swap!. +; swap! pega uma funçnao and chama ela com o valor atual do atom +; como primeiro argumento, e qualquer argumento restante como o segundo +(swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2) + +; Use '@' para desreferenciar um atom e acessar seu valor +my-atom ;=> Atom<#...> (Retorna o objeto do Atom) +@my-atom ; => {:a 1 :b 2} + +; Abaixo um contador simples usando um atom +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; Outras construção STM são refs e agents. +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### Leitura adicional + +Esse tutorial está longe de ser exaustivo, mas deve ser suficiente para que você possa começar. + +Clojure.org tem vários artigos: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core): +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure é um grande jeito de aperfeiçoar suas habilidades em Clojure/Programação Funcional: +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org tem um bom número de artigos para iniciantes: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown new file mode 100644 index 00000000..8b1094b1 --- /dev/null +++ b/pt-br/coffeescript-pt.html.markdown @@ -0,0 +1,106 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +filename: learncoffeescript-pt.coffee +--- + +CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript +equivalente, e não há interpretação em tempo de execução. Como um dos sucessores +de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, +bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de +execução JavaScript. + +Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial +completo sobre CoffeeScript. + +``` coffeescript +#CoffeeScript é uma linguagem moderna +#Segue as tendências de muitas linguagens modernas +#Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos. + +### +Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e +'* /'s para o código JavaScript que resulta... + +Você deveria entender mais de semântica de JavaScript antes de continuar... +### + +# Tarefa: +numero = 42 #=> número var = 42; +oposto = true #=> var oposto = true; + +# Condições: +numero = -42 if oposto #=> if (oposto) {número = -42;} + +# Funções: +quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;} + +preencher = (recipiente, líquido = "coffee") -> + "Preenchendo o #{recipiente} with #{líquido}..." +#=>var preencher; +# +#preencher = function(recipiente, líquido) { +# if (líquido == null) { +# líquido = "coffee"; +# } +# return "Preenchendo o " + recipiente + " with " + líquido + "..."; +#}; + +# Alcances: +list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5]; + +# Objetos: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Splats: +corrida = (vencedor, corredores...) -> + print vencedor, corredores +#=>corrida = function() { +# var corredores, vencedor; +# vencedor = arguments[0], corredores = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(vencedor, corredores); +#}; + +# Existências: +alert "Eu sabia!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); } + +# Compressão de Matrizes: +cubes = (math.cube num for num in list) +#=>cubes = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +comidas = ['brócolis', 'espinafre', 'chocolate'] +eat alimento for alimento in comidas when alimento isnt 'chocolate' +#=>comidas = ['brócolis', 'espinafre', 'chocolate']; +# +#for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) { +# alimento = comidas[_k]; +# if (alimento !== 'chocolate') { +# eat(alimento); +# } + +## Recursos adicionais + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
\ No newline at end of file diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown new file mode 100644 index 00000000..03a7c15c --- /dev/null +++ b/pt-br/common-lisp-pt.html.markdown @@ -0,0 +1,622 @@ +--- +language: "Common Lisp" +filename: commonlisp-pt.lisp +contributors: + - ["Paul Nathan", "https://github.com/pnathan"] +translators: + - ["Édipo Luis Féderle", "https://github.com/edipofederle"] +lang: pt-br +--- + +ANSI Common Lisp é uma linguagem de uso geral, multi-paradigma, designada +para uma variedade de aplicações na indústria. É frequentemente citada +como uma linguagem de programação programável. + + +O ponto inicial clássico é [Practical Common Lisp e livremente disponível](http://www.gigamonkeys.com/book/) + +Outro livro recente e popular é o +[Land of Lisp](http://landoflisp.com/). + + +```common_lisp + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 0. Sintaxe +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; "Form" Geral + + +;; Lisp tem dois pedaços fundamentais de sintaxe: o ATOM e S-expression. +;; Tipicamente, S-expressions agrupadas são chamadas de `forms`. + + +10 ; um atom; é avaliado para ele mesmo + +:THING ;Outro atom; avaliado para o símbolo :thing. + +t ; outro atom, denotado true. + +(+ 1 2 3 4) ; uma s-expression + +'(4 :foo t) ;outra s-expression + + +;;; Comentários + +;; Comentários de uma única linha começam com ponto e vírgula; usar dois para +;; comentários normais, três para comentários de seção, e quadro para comentários +;; em nível de arquivo. + +#| Bloco de comentário + pode abranger várias linhas e... + #| + eles podem ser aninhados + |# +|# + +;;; Ambiente + +;; Existe uma variedade de implementações; a maioria segue o padrão. +;; CLISP é um bom ponto de partida. + +;; Bibliotecas são gerenciadas através do Quicklisp.org's Quicklisp sistema. + +;; Common Lisp é normalmente desenvolvido com um editor de texto e um REPL +;; (Read Evaluate Print Loop) rodando ao mesmo tempo. O REPL permite exploração +;; interativa do programa como ele é "ao vivo" no sistema. + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 1. Tipos Primitivos e Operadores +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Símbolos + +'foo ; => FOO Perceba que um símbolo é automáticamente convertido para maiúscula. + +;; Intern manualmente cria um símbolo a partir de uma string. + +(intern "AAAA") ; => AAAA + +(intern "aaa") ; => |aaa| + +;;; Números +9999999999999999999999 ; inteiro +#b111 ; binário => 7 +#o111 ; octal => 73 +#x111 ; hexadecimal => 273 +3.14159s0 ; single +3.14159d0 ; double +1/2 ; ratios +#C(1 2) ; números complexos + + +;; Funções são escritas como (f x y z ...) +;; onde f é uma função e x, y, z, ... são operadores +;; Se você quiser criar uma lista literal de dados, use ' para evitar +;; que a lista seja avaliada - literalmente, "quote" os dados. +'(+ 1 2) ; => (+ 1 2) +;; Você também pode chamar uma função manualmente: +(funcall #'+ 1 2 3) ; => 6 +;; O mesmo para operações aritiméticas +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(mod 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(+ #C(1 2) #C(6 -4)) ; => #C(7 -2) + + ;;; Booleans +t ; para true (qualquer valor não nil é true) +nil ; para false - e para lista vazia +(not nil) ; => t +(and 0 t) ; => t +(or 0 nil) ; => 0 + + ;;; Caracteres +#\A ; => #\A +#\λ ; => #\GREEK_SMALL_LETTER_LAMDA +#\u03BB ; => #\GREEK_SMALL_LETTER_LAMDA + +;;; String são arrays de caracteres com tamanho fixo. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; barra é um escape de caracter + +;; String podem ser concatenadas também! +(concatenate 'string "Hello " "world!") ; => "Hello world!" + +;; Uma String pode ser tratada como uma sequência de caracteres +(elt "Apple" 0) ; => #\A + +;; format pode ser usado para formatar strings +(format nil "~a can be ~a" "strings" "formatted") + +;; Impimir é bastante fácil; ~% indica nova linha +(format t "Common Lisp is groovy. Dude.~%") + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variáveis +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Você pode criar uma global (escopo dinâmico) usando defparameter +;; um nome de variável pode conter qualquer caracter, exceto: ()",'`;#|\ + +;; Variáveis de escopo dinâmico devem ter asteriscos em seus nomes! + +(defparameter *some-var* 5) +*some-var* ; => 5 + +;; Você pode usar caracteres unicode também. +(defparameter *AΛB* nil) + + +;; Acessando uma variável anteriormente não ligada é um +;; comportamento não definido (mas possível). Não faça isso. + +;; Ligação local: `me` é vinculado com "dance with you" somente dentro +;; de (let ... ). Let permite retornar o valor do último `form` no form let. + +(let ((me "dance with you")) + me) +;; => "dance with you" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Estruturas e Coleções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Estruturas +(defstruct dog name breed age) +(defparameter *rover* + (make-dog :name "rover" + :breed "collie" + :age 5)) +*rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5) + +(dog-p *rover*) ; => t ;; ewww) +(dog-name *rover*) ; => "rover" + +;; Dog-p, make-dog, e dog-name foram todas criadas por defstruct! + +;;; Pares +;; `cons' constroi pares, `car' and `cdr' extrai o primeiro +;; e o segundo elemento +(cons 'SUBJECT 'VERB) ; => '(SUBJECT . VERB) +(car (cons 'SUBJECT 'VERB)) ; => SUBJECT +(cdr (cons 'SUBJECT 'VERB)) ; => VERB + +;;; Listas + +;; Listas são estruturas de dados do tipo listas encadeadas, criadas com `cons' +;; pares e terminam `nil' (ou '()) para marcar o final da lista +(cons 1 (cons 2 (cons 3 nil))) ; => '(1 2 3) +;; `list' é um construtor conveniente para listas +(list 1 2 3) ; => '(1 2 3) +;; e a quote (') também pode ser usado para um valor de lista literal +'(1 2 3) ; => '(1 2 3) + +;; Ainda pode-se usar `cons' para adicionar um item no começo da lista. +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; Use `append' para - surpreendentemente - juntar duas listas +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; Ou use concatenate - + +(concatenate 'list '(1 2) '(3 4)) + +;; Listas são um tipo muito central, então existe uma grande variedade de +;; funcionalidades para eles, alguns exemplos: +(mapcar #'1+ '(1 2 3)) ; => '(2 3 4) +(mapcar #'+ '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4) +(every #'evenp '(1 2 3 4)) ; => nil +(some #'oddp '(1 2 3 4)) ; => T +(butlast '(subject verb object)) ; => (SUBJECT VERB) + + +;;; Vetores + +;; Vector's literais são arrays de tamanho fixo. +#(1 2 3) ; => #(1 2 3) + +;; Use concatenate para juntar dois vectors +(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Arrays + +;; Ambos vetores e strings são um caso especial de arrays. + +;; 2D arrays + +(make-array (list 2 2)) + +;; (make-array '(2 2)) também funciona. + +; => #2A((0 0) (0 0)) + +(make-array (list 2 2 2)) + +; => #3A(((0 0) (0 0)) ((0 0) (0 0))) + +;; Cuidado - os valores de inicialição padrões são +;; definidos pela implementção. Aqui vai como defini-lós. + +(make-array '(2) :initial-element 'unset) + +; => #(UNSET UNSET) + +;; E, para acessar o element em 1,1,1 - +(aref (make-array (list 2 2 2)) 1 1 1) + +; => 0 + +;;; Vetores Ajustáveis + +;; Vetores ajustáveis tem a mesma representação impressa que os vectores +;; de tamanho fixo +(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3) + :adjustable t :fill-pointer t)) + +*adjvec* ; => #(1 2 3) + +;; Adicionando novo elemento +(vector-push-extend 4 *adjvec*) ; => 3 + +*adjvec* ; => #(1 2 3 4) + + + +;;; Ingenuamente, conjuntos são apenas listas: + +(set-difference '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1) +(intersection '(1 2 3 4) '(4 5 6 7)) ; => 4 +(union '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1 4 5 6 7) +(adjoin 4 '(1 2 3 4)) ; => (1 2 3 4) + +;; Mas você irá querer usar uma estrutura de dados melhor que uma lista encadeada. +;; para performance. + +;;; Dicionários são implementados como hash tables + +;; Cria um hash table +(defparameter *m* (make-hash-table)) + +;; seta um valor +(setf (gethash 'a *m*) 1) + +;; Recupera um valor +(gethash 'a *m*) ; => 1, t + +;; Detalhe - Common Lisp tem multiplos valores de retorno possíveis. gethash +;; retorna t no segundo valor se alguma coisa foi encontrada, e nil se não. + +;; Recuperando um valor não presente retorna nil + (gethash 'd *m*) ;=> nil, nil + +;; Você pode fornecer um valor padrão para uma valores não encontrados +(gethash 'd *m* :not-found) ; => :NOT-FOUND + +;; Vamos tratas múltiplos valores de rotorno aqui. + +(multiple-value-bind + (a b) + (gethash 'd *m*) + (list a b)) +; => (NIL NIL) + +(multiple-value-bind + (a b) + (gethash 'a *m*) + (list a b)) +; => (1 T) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Funções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `lambda' para criar funções anônimas +;; Uma função sempre retorna um valor da última expressão avaliada. +;; A representação exata impressão de uma função varia de acordo ... + +(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}> + +;; Use funcall para chamar uma função lambda. +(funcall (lambda () "Hello World")) ; => "Hello World" + +;; Ou Apply +(apply (lambda () "Hello World") nil) ; => "Hello World" + +;; "De-anonymize" a função +(defun hello-world () + "Hello World") +(hello-world) ; => "Hello World" + +;; O () acima é a lista de argumentos da função. +(defun hello (name) + (format nil "Hello, ~a " name)) + +(hello "Steve") ; => "Hello, Steve" + +;; Funções podem ter argumentos opcionais; eles são nil por padrão + +(defun hello (name &optional from) + (if from + (format t "Hello, ~a, from ~a" name from) + (format t "Hello, ~a" name))) + + (hello "Jim" "Alpacas") ;; => Hello, Jim, from Alpacas + +;; E os padrões podem ser configurados... +(defun hello (name &optional (from "The world")) + (format t "Hello, ~a, from ~a" name from)) + +(hello "Steve") +; => Hello, Steve, from The world + +(hello "Steve" "the alpacas") +; => Hello, Steve, from the alpacas + + +;; E é claro, palavras-chaves são permitidas também... frequentemente mais +;; flexivel que &optional. + +(defun generalized-greeter (name &key (from "the world") (honorific "Mx")) + (format t "Hello, ~a ~a, from ~a" honorific name from)) + +(generalized-greeter "Jim") ; => Hello, Mx Jim, from the world + +(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr") +; => Hello, Mr Jim, from the alpacas you met last summer + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Igualdade +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Common Lisp tem um sistema sofisticado de igualdade. Alguns são cobertos aqui. + +;; Para número use `=' +(= 3 3.0) ; => t +(= 2 1) ; => nil + +;; para identidade de objeto (aproximadamente) use `eql` +(eql 3 3) ; => t +(eql 3 3.0) ; => nil +(eql (list 3) (list 3)) ; => nil + +;; para listas, strings, e para pedaços de vetores use `equal' +(equal (list 'a 'b) (list 'a 'b)) ; => t +(equal (list 'a 'b) (list 'b 'a)) ; => nil + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Fluxo de Controle +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Condicionais + +(if t ; testa a expressão + "this is true" ; então expressão + "this is false") ; senão expressão +; => "this is true" + +;; Em condicionais, todos valores não nulos são tratados como true +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'YEP + +;; `cond' encadeia uma série de testes para selecionar um resultado +(cond ((> 2 2) (error "wrong!")) + ((< 2 2) (error "wrong again!")) + (t 'ok)) ; => 'OK + +;; Typecase é um condicional que escolhe uma de seus cláusulas com base do tipo +;; do seu valor + +(typecase 1 + (string :string) + (integer :int)) + +; => :int + +;;; Interação + +;; Claro que recursão é suportada: + +(defun walker (n) + (if (zerop n) + :walked + (walker (1- n)))) + +(walker 5) ; => :walked + +;; Na maioria das vezes, nós usamos DOTLISO ou LOOP + +(dolist (i '(1 2 3 4)) + (format t "~a" i)) + +; => 1234 + +(loop for i from 0 below 10 + collect i) + +; => (0 1 2 3 4 5 6 7 8 9) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutação +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `setf' para atribuir um novo valor para uma variável existente. Isso foi +;; demonstrado anteriormente no exemplo da hash table. + +(let ((variable 10)) + (setf variable 2)) + ; => 2 + + +;; Um bom estilo Lisp é para minimizar funções destrutivas e para evitar +;; mutação quando razoável. + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Classes e Objetos +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Sem clases Animal, vamos usar os veículos de transporte de tração +;; humana mecânicos. + +(defclass human-powered-conveyance () + ((velocity + :accessor velocity + :initarg :velocity) + (average-efficiency + :accessor average-efficiency + :initarg :average-efficiency)) + (:documentation "A human powered conveyance")) + +;; defcalss, seguido do nome, seguido por uma list de superclass, +;; seguido por um uma 'slot list', seguido por qualidades opcionais como +;; :documentation + +;; Quando nenhuma lista de superclasse é setada, uma lista padrão para +;; para o objeto padrão é usada. Isso *pode* ser mudado, mas não até você +;; saber o que está fazendo. Olhe em Art of the Metaobject Protocol +;; para maiores informações. + +(defclass bicycle (human-powered-conveyance) + ((wheel-size + :accessor wheel-size + :initarg :wheel-size + :documentation "Diameter of the wheel.") + (height + :accessor height + :initarg :height))) + +(defclass recumbent (bicycle) + ((chain-type + :accessor chain-type + :initarg :chain-type))) + +(defclass unicycle (human-powered-conveyance) nil) + +(defclass canoe (human-powered-conveyance) + ((number-of-rowers + :accessor number-of-rowers + :initarg :number-of-rowers))) + + +;; Chamando DESCRIBE na classe human-powered-conveyance no REPL dá: + +(describe 'human-powered-conveyance) + +; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE +; [symbol] +; +; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS +; HUMAN-POWERED-CONVEYANCE>: +; Documentation: +; A human powered conveyance +; Direct superclasses: STANDARD-OBJECT +; Direct subclasses: UNICYCLE, BICYCLE, CANOE +; Not yet finalized. +; Direct slots: +; VELOCITY +; Readers: VELOCITY +; Writers: (SETF VELOCITY) +; AVERAGE-EFFICIENCY +; Readers: AVERAGE-EFFICIENCY +; Writers: (SETF AVERAGE-EFFICIENCY) + +;; Note o comportamento reflexivo disponível para você! Common Lisp é +;; projetada para ser um sistema interativo. + +;; Para definir um métpdo, vamos encontrar o que nossa cirunferência da +;; roda da bicicleta usando a equação: C = d * pi + +(defmethod circumference ((object bicycle)) + (* pi (wheel-size object))) + +;; pi já é definido para a gente em Lisp! + +;; Vamos supor que nós descobrimos que o valor da eficiência do número +;; de remadores em uma canoa é aproximadamente logarítmica. Isso provavelmente +;; deve ser definido no construtor / inicializador. + +;; Veja como initializar sua instância após Common Lisp ter construído isso: + +(defmethod initialize-instance :after ((object canoe) &rest args) + (setf (average-efficiency object) (log (1+ (number-of-rowers object))))) + +;; Em seguida, para a construção de uma ocorrência e verificar a eficiência média ... + +(average-efficiency (make-instance 'canoe :number-of-rowers 15)) +; => 2.7725887 + + + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Macros permitem que você estenda a sintaxe da lingaugem + +;; Common Lisp não vem com um loop WHILE - vamos adicionar um. +;; Se obedecermos nossos instintos 'assembler', acabamos com: + +(defmacro while (condition &body body) + "Enquanto `condition` é verdadeiro, `body` é executado. + +`condition` é testado antes de cada execução do `body`" + (let ((block-name (gensym))) + `(tagbody + (unless ,condition + (go ,block-name)) + (progn + ,@body) + ,block-name))) + +;; Vamos dar uma olhada em uma versão alto nível disto: + + +(defmacro while (condition &body body) + "Enquanto `condition` for verdadeira, `body` é executado. + +`condition` é testado antes de cada execução do `body`" + `(loop while ,condition + do + (progn + ,@body))) + +;; Entretanto, com um compilador moderno, isso não é preciso; o LOOP +;; 'form' compila igual e é bem mais fácil de ler. + +;; Noteq ue ``` é usado , bem como `,` e `@`. ``` é um operador 'quote-type' +;; conhecido como 'quasiquote'; isso permite o uso de `,` . `,` permite "unquoting" +;; e variáveis. @ interpolará listas. + +;; Gensym cria um símbolo único garantido que não existe em outras posições +;; o sistema. Isto é porque macros são expandidas em tempo de compilação e +;; variáveis declaradas na macro podem colidir com as variáveis usadas na +;; código regular. + +;; Veja Practical Common Lisp para maiores informações sobre macros. +``` + + +## Leitura Adicional + +[Continua em frente com Practical Common Lisp book.](http://www.gigamonkeys.com/book/) + + +## Créditos + +Muitos agradecimentos ao pessoal de Schema por fornecer um grande ponto de partida +o que facilitou muito a migração para Common Lisp. + +- [Paul Khuong](https://github.com/pkhuong) pelas grandes revisões. diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown new file mode 100644 index 00000000..fc2d1e40 --- /dev/null +++ b/pt-br/elisp-pt.html.markdown @@ -0,0 +1,359 @@ +--- +language: elisp +contributors: + - ["Bastien Guerry", "http://bzg.fr"] +translators: + - ["Lucas Tadeu Teixeira", "http://ltt.me"] +lang: pt-br +filename: learn-emacs-lisp-pt.el +--- + +```scheme +;; Introdução ao Emacs Lisp em 15 minutos (v0.2d) +;; +;; Autor: Bastien / @bzg2 / http://bzg.fr +;; +;; Antes de começar, leia este texto escrito Peter Norvig: +;; http://norvig.com/21-days.html +;; +;; Agora instale GNU Emacs 24.3: +;; +;; Debian: apt-get install emacs (ou veja as instruções da sua distribuição) +;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg +;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip +;; +;; Informações mais gerais podem ser encontradas em: +;; http://www.gnu.org/software/emacs/#Obtaining + +;; Aviso importante: +;; +;; Realizar este tutorial não danificará seu computador, a menos +;; que você fique tão irritado a ponto de jogá-lo no chão. Neste caso, +;; me abstenho de qualquer responsabilidade. Divirta-se! + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Abra o Emacs. +;; +;; Aperte a tecla `q' para ocultar a mensagem de boas vindas. +;; +;; Agora olhe para a linha cinza na parte inferior da janela: +;; +;; "*scratch*" é o nome do espaço de edição em que você se encontra. +;; Este espaço de edição é chamado "buffer". +;; +;; O buffer de rascunho (i.e., "scratch") é o buffer padrão quando +;; o Emacs é aberto. Você nunca está editando arquivos: você está +;; editando buffers que você pode salvar em um arquivo. +;; +;; "Lisp interaction" refere-se a um conjunto de comandos disponíveis aqui. +;; +;; O Emacs possui um conjunto de comandos embutidos (disponíveis em +;; qualquer buffer) e vários subconjuntos de comandos disponíveis +;; quando você ativa um modo específico. Aqui nós utilizamos +;; `lisp-interaction-mode', que possui comandos para interpretar e navegar +;; em código Elisp. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Pontos e vírgulas iniciam comentários em qualquer parte de uma linha. +;; +;; Programas codificados em Elisp são compostos por expressões simbólicas +;; (conhecidas também por "sexps"): +(+ 2 2) + +;; Esta expressão simbólica significa "Some 2 e 2". + +;; "Sexps" são envoltas em parêntese, possivelmente aninhados: +(+ 2 (+ 1 1)) + +;; Uma expressão simbólica contém átomos ou outras expressões +;; simbólicas. Nos exemplos acima, 1 e 2 são átomos; +;; (+ 2 (+ 1 1)) e (+ 1 1) são expressões simbólicas. + +;; No modo `lisp-interaction-mode' você pode interpretar "sexps". +;; Posicione o cursor logo após o parêntese de fechamento e, +;; então, segure apertado Ctrl e aperte a tecla j ("C-j", em resumo). + +(+ 3 (+ 1 2)) +;; ^ posicione o cursor aqui +;; `C-j' => 6 + +;; `C-j' insere o resultado da interpretação da expressão no buffer. + +;; `C-xC-e' exibe o mesmo resultado na linha inferior do Emacs, +;; chamada de "mini-buffer". Nós geralmente utilizaremos `C-xC-e', +;; já que não queremos poluir o buffer com texto desnecessário. + +;; `setq' armazena um valor em uma variável: +(setq my-name "Bastien") +;; `C-xC-e' => "Bastien" (texto exibido no mini-buffer) + +;; `insert' insere "Hello!" na posição em que se encontra seu cursor: +(insert "Hello!") +;; `C-xC-e' => "Hello!" + +;; Nós executamos `insert' com apenas um argumento ("Hello!"), mas +;; mais argumentos podem ser passados -- aqui utilizamos dois: + +(insert "Hello" " world!") +;; `C-xC-e' => "Hello world!" + +;; Você pode utilizar variávies no lugar de strings: +(insert "Hello, I am " my-name) +;; `C-xC-e' => "Hello, I am Bastien" + +;; Você pode combinar "sexps" em funções: +(defun hello () (insert "Hello, I am " my-name)) +;; `C-xC-e' => hello + +;; Você pode interpretar chamadas de funções: +(hello) +;; `C-xC-e' => Hello, I am Bastien + +;; Os parêntesis vazios na definição da função significam que ela +;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio! +;; Vamos dizer à função para aceitar um argumento (o argumento é +;; chamado "name"): + +(defun hello (name) (insert "Hello " name)) +;; `C-xC-e' => hello + +;; Agora vamos executar a função com a string "you" como o valor +;; para seu único parâmetro: +(hello "you") +;; `C-xC-e' => "Hello you" + +;; Aí sim! + +;; Respire um pouco. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Agora mude para um novo buffer chamado "*test*": + +(switch-to-buffer-other-window "*test*") +;; `C-xC-e' +;; => [a tela exibirá duas janelas e o cursor estará no buffer *test*] + +;; Posicione o mouse sobre a janela superior e clique com o botão +;; esquerdo para voltar. Ou você pode utilizar `C-xo' (i.e. segure +;; ctrl-x e aperte o) para voltar para a outra janela, de forma interativa. + +;; Você pode combinar várias "sexps" com `progn': +(progn + (switch-to-buffer-other-window "*test*") + (hello "you")) +;; `C-xC-e' +;; => [A tela exibirá duas janelas e o cursor estará no buffer *test*] + +;; Agora, se você não se importar, pararei de pedir que você aperte +;; `C-xC-e': faça isso para cada "sexp" que escrevermos. + +;; Sempre volte para o buffer *scratch* com o mouse ou `C-xo'. + +;; Frequentemente, é útil apagar o conteúdo do buffer: +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "there")) + +;; Ou voltar para a outra janela: +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "you") + (other-window 1)) + +;; Você pode armazenar um valor em uma variável local utilizando `let': +(let ((local-name "you")) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello local-name) + (other-window 1)) + +;; Neste caso, não é necessário utilizar `progn' já que `let' combina +;; várias "sexps". + +;; Vamos formatar uma string: +(format "Hello %s!\n" "visitor") + +;; %s é um espaço reservado para uma string, substituído por "visitor". +;; \n é um caractere de nova linha. + +;; Vamos refinar nossa função utilizando `format': +(defun hello (name) + (insert (format "Hello %s!\n" name))) + +(hello "you") + +;; Vamos criar outra função que utilize `let': +(defun greeting (name) + (let ((your-name "Bastien")) + (insert (format "Hello %s!\n\nI am %s." + name ; the argument of the function + your-name ; the let-bound variable "Bastien" + )))) + +;; E executá-la: +(greeting "you") + +;; Algumas funções são interativas: +(read-from-minibuffer "Enter your name: ") + +;; Ao ser interpretada, esta função retorna o que você digitou no prompt. + +;; Vamos fazer nossa função `greeting' pedir pelo seu nome: +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (insert (format "Hello!\n\nI am %s and you are %s." + from-name ; the argument of the function + your-name ; the let-bound var, entered at prompt + )))) + +(greeting "Bastien") + +;; Vamos finalizá-la fazendo-a exibir os resultados em outra janela: +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (insert (format "Hello %s!\n\nI am %s." your-name from-name)) + (other-window 1))) + +;; Agora teste-a: +(greeting "Bastien") + +;; Respire um pouco. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Vamos armazenar uma lista de nomes: +(setq list-of-names '("Sarah" "Chloe" "Mathilde")) + +;; Pegue o primeiro elemento desta lista utilizando `car': +(car list-of-names) + +;; Pegue uma lista de todos os elementos, exceto o primeiro, utilizando +;; `cdr': +(cdr list-of-names) + +;; Adicione um elemento ao início da lista com `push': +(push "Stephanie" list-of-names) + +;; NOTA: `car' e `cdr' não modificam a lista, `push' sim. +;; Esta é uma diferença importante: algumas funções não têm qualquer +;; efeito colateral (como `car'), enquanto outras sim (como `push'). + +;; Vamos executar `hello' para cada elemento em `list-of-names': +(mapcar 'hello list-of-names) + +;; Refine `greeting' para saudar todos os nomes em `list-of-names': +(defun greeting () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (mapcar 'hello list-of-names) + (other-window 1)) + +(greeting) + +;; Você se lembra da função `hello' que nós definimos lá em cima? Ela +;; recebe um argumento, um nome. `mapcar' executa `hello', sucessivamente, +;; utilizando cada elemento de `list-of-names' como argumento para `hello'. + +;; Agora vamos arrumar, um pouco, o que nós temos escrito no buffer: + +(defun replace-hello-by-bonjour () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (search-forward "Hello") + (replace-match "Bonjour")) + (other-window 1)) + +;; (goto-char (point-min)) vai para o início do buffer. +;; (search-forward "Hello") busca pela string "Hello". +;; (while x y) interpreta a(s) sexp(s) y enquanto x retornar algo. +;; Se x retornar `nil' (nada), nós saímos do laço. + +(replace-hello-by-bonjour) + +;; Você deveria ver todas as ocorrências de "Hello" no buffer *test* +;; substituídas por "Bonjour". + +;; Você deveria, também, receber um erro: "Search failed: Hello". +;; +;; Para evitar este erro, você precisa dizer ao `search-forward' se ele +;; deveria parar de buscar em algum ponto no buffer, e se ele deveria +;; falhar de forma silenciosa quando nada fosse encontrado: + +;; (search-forward "Hello" nil t) dá conta do recado: + +;; O argumento `nil' diz: a busca não está limitada a uma posição. +;; O argumento `t' diz: falhe silenciosamente quando nada for encontrado. + +;; Nós utilizamos esta "sexp" na função abaixo, que não gera um erro: + +(defun hello-to-bonjour () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + ;; Say hello to names in `list-of-names' + (mapcar 'hello list-of-names) + (goto-char (point-min)) + ;; Replace "Hello" by "Bonjour" + (while (search-forward "Hello" nil t) + (replace-match "Bonjour")) + (other-window 1)) + +(hello-to-bonjour) + +;; Vamos colorir os nomes: + +(defun boldify-names () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (re-search-forward "Bonjour \\(.+\\)!" nil t) + (add-text-properties (match-beginning 1) + (match-end 1) + (list 'face 'bold))) + (other-window 1)) + +;; Esta função introduz `re-search-forward': ao invés de buscar +;; pela string "Bonjour", você busca por um padrão utilizando uma +;; "expressão regular" (abreviada pelo prefixo "re-"). + +;; A expressão regular é "Bonjour \\(.+\\)!" e lê-se: +;; a string "Bonjour ", e +;; um grupo de | que é o \\( ... \\) +;; quaisquer caracteres | que é o . +;; possivelmente repetidos | que é o + +;; e a string "!". + +;; Preparado? Teste! + +(boldify-names) + +;; `add-text-properties' adiciona... propriedades de texto, como uma fonte. + +;; OK, terminamos por aqui. Feliz Hacking! + +;; Se você quiser saber mais sobre uma variável ou função: +;; +;; C-h v uma-variável RET +;; C-h f uma-função RET +;; +;; Para ler o manual de Emacs Lisp que vem com o Emacs: +;; +;; C-h i m elisp RET +;; +;; Para ler uma introdução online ao Emacs Lisp: +;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html + +;; Agradecimentos a estas pessoas por seu feedback e sugestões: +;; - Wes Hardaker +;; - notbob +;; - Kevin Montuori +;; - Arne Babenhauserheide +;; - Alan Schmitt +;; - LinXitoW +;; - Aaron Meurer +``` diff --git a/pt-br/erlang-pt.html.markdown b/pt-br/erlang-pt.html.markdown new file mode 100644 index 00000000..a81e5a1f --- /dev/null +++ b/pt-br/erlang-pt.html.markdown @@ -0,0 +1,254 @@ +--- +language: erlang +filename: learnerlang-pt.erl +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] +translators: + - ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"] +lang: pt-br +--- + +```erlang +% Símbolo de porcento começa comentários de uma linha. + +%% Dois caracteres de porcento devem ser usados para comentar funções. + +%%% Três caracteres de porcento devem ser usados para comentar módulos. + +% Nós usamos três tipos de pontuação em Erlang. +% Vírgulas (`,`) separam argumentos em chamadas de função, construtores de +% dados, e padrões. +% Pontos finais (`.`) separam totalmente funções e expressões no prompt. +% Ponto e vírgulas (`;`) separam cláusulas. Nós encontramos cláusulas em +% vários contextos: definições de função e em expressões com `case`, `if`, +% `try..catch` e `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Variáveis e casamento de padrões. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Num = 42. % Todos nomes de variáveis devem começar com uma letra maiúscula. + +% Erlang tem atribuição única de variáveis, se você tentar atribuir um valor +% diferente à variável `Num`, você receberá um erro. +Num = 43. % ** exception error: no match of right hand side value 43 + +% Na maioria das linguagens, `=` denota um comando de atribuição. Em Erlang, no +% entanto, `=` denota uma operação de casamento de padrão. `Lhs = Rhs` realmente +% significa isso: avalia o lado direito (Rhs), e então casa o resultado com o +% padrão no lado esquerdo (Lhs). +Num = 7 * 6. + +% Número de ponto flutuante. +Pi = 3.14159. + +% Átomos são usados para representar diferentes valores constantes não +% numéricos. Átomos começam com letras minúsculas seguidas por uma sequência de +% caracteres alfanuméricos ou sinais de subtraço (`_`) ou arroba (`@`). +Hello = hello. +OtherNode = example@node. + +% Átomos com valores alfanuméricos podem ser escritos colocando aspas por fora +% dos átomos. +AtomWithSpace = 'some atom with space'. + +% Tuplas são similares a structs em C. +Point = {point, 10, 45}. + +% Se nós queremos extrair alguns valores de uma tupla, nós usamos o operador `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% Nós podemos usar `_` para ocupar o lugar de uma variável que não estamos interessados. +% O símbolo `_` é chamado de variável anônima. Ao contrário de variáveis regulares, +% diversas ocorrências de _ no mesmo padrão não precisam se amarrar ao mesmo valor. +Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. +{_, {_, {_, Who}, _}, _} = Person. % Who = joe + +% Nós criamos uma lista colocando valores separados por vírgula entre colchetes. +% Cada elemento de uma lista pode ser de qualquer tipo. +% O primeiro elemento de uma lista é a cabeça da lista. Se removermos a cabeça +% da lista, o que sobra é chamado de cauda da lista. +ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. + +% Se `T` é uma lista, então `[H|T]` também é uma lista, com cabeça `H` e cauda `T`. +% A barra vertical (`|`) separa a cabeça de uma lista de sua cauda. +% `[]` é uma lista vazia. +% Podemos extrair elementos de uma lista com uma operação de casamento de +% padrão. Se temos uma lista não-vazia `L`, então a expressão `[X|Y] = L`, onde +% `X` e `Y` são variáveis desamarradas, irá extrair a cabeça de uma lista para +% `X` e a cauda da lista para `Y`. +[FirstThing|OtherThingsToBuy] = ThingsToBuy. +% FirstThing = {apples, 10} +% OtherThingsToBuy = {pears, 6}, {milk, 3} + +% Não existe o tipo string em Erlang. Strings são somente listas de inteiros. +% Strings são representadas dentro de aspas duplas (`"`). +Name = "Hello". +[72, 101, 108, 108, 111] = "Hello". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Programação sequencial. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Módulos são a unidade básica de código em Erlang. Todas funções que +% escrevemos são armazenadas em módulos. Módulos são armazenados em arquivos +% com extensão `.erl`. +% Módulos devem ser compilados antes que o código possa ser rodado. Um módulo +% compilado tem a extensão `.beam`. +-module(geometry). +-export([area/1]). % lista de funções exportadas de um módulo. + +% A função `area` consiste de duas cláusulas. As cláusulas são separadas por um +% ponto e vírgula, e a cláusula final é terminada por um ponto final. +% Cada cláusula tem uma cabeça em um corpo; a cabeça consiste de um nome de +% função seguido por um padrão (entre parêntesis), e o corpo consiste de uma +% sequência de expressões, que são avaliadas se o padrão na cabeça é um par bem +% sucedido dos argumentos da chamada. Os padrões são casados na ordem que +% aparecem na definição da função. +area({rectangle, Width, Ht}) -> Width * Ht; +area({circle, R}) -> 3.14159 * R * R. + +% Compila o código no arquivo geometry.erl. +c(geometry). % {ok,geometry} + +% Nós precisamos incluir o nome do módulo junto com o nome da função de maneira +% a identificar exatamente qual função queremos chamar. +geometry:area({rectangle, 10, 5}). % 50 +geometry:area({circle, 1.4}). % 6.15752 + +% Em Erlang, duas funções com o mesmo nome e diferentes aridades (números de +% argumentos) no mesmo módulo representam funções totalmente diferentes. +-module(lib_misc). +-export([sum/1]). % exporta a função `sum` de aridade 1 aceitando um argumento: lista de inteiros. +sum(L) -> sum(L, 0). +sum([], N) -> N; +sum([H|T], N) -> sum(T, H+N). + +% Funs são funções "anônimas". Elas são chamadas desta maneira por que elas não +% têm nome. No entanto podem ser atribuídas a variáveis. +Double = fun(X) -> 2*X end. % `Double` aponta para uma função anônima com referência: #Fun<erl_eval.6.17052888> +Double(2). % 4 + +% Funções aceitam funs como seus argumentos e podem retornar funs. +Mult = fun(Times) -> ( fun(X) -> X * Times end ) end. +Triple = Mult(3). +Triple(5). % 15 + +% Compreensão de lista são expressões que criam listas sem precisar usar funs, +% maps, ou filtros. +% A notação `[F(X) || X <- L]` significa "a lista de `F(X)` onde `X` é tomada +% da lista `L`." +L = [1,2,3,4,5]. +[2*X || X <- L]. % [2,4,6,8,10] +% Uma compreensão de lista pode ter geradores e filtros que selecionam +% subconjuntos dos valores gerados. +EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% Sentinelas são contruções que podemos usar para incrementar o poder de +% casamento de padrão. Usando sentinelas, podemos executar testes simples e +% comparações nas variáveis em um padrão. +% Você pode usar sentinelas nas cabeças das definições de função onde eles são +% introduzidos pela palavra-chave `when`, ou você pode usá-los em qualquer +% lugar na linguagem onde uma expressão é permitida. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Um sentinela é uma série de expressões sentinelas, separadas por +% vírgulas (`,`). +% O sentinela `GuardExpr1, GuardExpr2, ..., GuardExprN` é verdadeiro se todas +% expressões sentinelas `GuardExpr1, GuardExpr2, ...` forem verdadeiras. +is_cat(A) when is_atom(A), A =:= cat -> true; +is_cat(A) -> false. +is_dog(A) when is_atom(A), A =:= dog -> true; +is_dog(A) -> false. + +% Uma `sequência sentinela` é um sentinela ou uma série de sentinelas separados +% por ponto e vírgula (`;`). A sequência sentinela `G1; G2; ...; Gn` é +% verdadeira se pelo menos um dos sentinelas `G1, G2, ...` for verdadeiro. +is_pet(A) when is_dog(A); is_cat(A) -> true; +is_pet(A) -> false. + +% Registros provêem um método para associar um nome com um elemento particular +% em uma tupla. +% Definições de registro podem ser incluídas em arquivos fonte Erlang ou em +% arquivos com extensão `.hrl`, que então são incluídos em arquivos fonte Erlang. +-record(todo, { + status = reminder, % Default value + who = joe, + text +}). + +% Nós temos que ler definições de registro no prompt antes que possamos definir +% um registro. Nós usamos a função de prompt `rr` (abreviação de read records) +% para fazer isso. +rr("records.hrl"). % [todo] + +% Criando e atualizando registros: +X = #todo{}. +% #todo{status = reminder, who = joe, text = undefined} +X1 = #todo{status = urgent, text = "Fix errata in book"}. +% #todo{status = urgent, who = joe, text = "Fix errata in book"} +X2 = X1#todo{status = done}. +% #todo{status = done,who = joe,text = "Fix errata in book"} + +% Expressões `case`. +% A função `filter` retorna uma lista de todos elementos `X` em uma lista `L` +% para qual `P(X)` é verdadeiro. +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% Expressões `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil; + end. + +% Aviso: pelo menos um dos sentinelas na expressão `if` deve retornar +% verdadeiro; Caso contrário, uma exceção será levantada. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Exceções. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Exceções são levantadas pelo sistema quando erros internos são encontrados ou +% explicitamente em código pela chamada `throw(Exception)`, `exit(Exception)` +% ou `erlang:error(Exception)`. +generate_exception(1) -> a; +generate_exception(2) -> throw(a); +generate_exception(3) -> exit(a); +generate_exception(4) -> {'EXIT', a}; +generate_exception(5) -> erlang:error(a). + +% Erlang tem dois métodos para capturar uma exceção. Uma é encapsular a chamada +% para a função que levanta uma exceção dentro de uma expressão `try...catch`. +catcher(N) -> + try generate_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% O outro é encapsular a chamada em uma expressão `catch`. Quando você captura +% uma exceção, é convertida em uma tupla que descreve o erro. +catcher(N) -> catch generate_exception(N). + +``` + +## Referências + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang2/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) + diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown new file mode 100644 index 00000000..981da503 --- /dev/null +++ b/pt-br/git-pt.html.markdown @@ -0,0 +1,412 @@ +--- +category: tool +tool: git +lang: pt-br +filename: LearnGit.txt +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["Suzane Sant Ana", "http://github.com/suuuzi"] +--- + +Git é um sistema distribuido de gestão para código fonte e controle de versões. + +Funciona através de uma série de registos de estado do projeto e usa esse +registo para permitir funcionalidades de versionamento e gestão de código +fonte. + +## Conceitos de versionamento + +### O que é controle de versão + +Controle de versão (*source control*) é um processo de registo de alterações +a um arquivo ou conjunto de arquivos ao longo do tempo. + +### Controle de versão: Centralizado VS Distribuído + +* Controle de versão centralizado foca na sincronização, registo e *backup* +de arquivos. +* Controle de versão distribuído foca em compartilhar alterações. Cada +alteração é associada a um *id* único. +* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema +centralizado ao estilo SVN usando git. + +[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### Por que usar git? + +* Permite trabalhar offline. +* Colaborar com outros é fácil! +* Criar *branches* é fácil! +* Fazer *merge* é fácil! +* Git é rápido. +* Git é flexivel. + +## Git - Arquitetura + + +### Repositório + +Um conjunto de arquivos, diretórios, registos históricos, *commits* e +referências. Pode ser descrito como uma estrutura de dados de código fonte +com a particularidade de cada elemento do código fonte permitir acesso ao +histórico das suas alterações, entre outras coisas. + +Um repositório git é constituido pelo diretório .git e a *working tree* + +### Diretório .git (componente do repositório) + +O repositório .git contém todas as configurações, *logs*, *branches*, +referências e outros. + +[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### *Working Tree* (componente do repositório) + +A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto. + +### *Index* (componente do diretório .git) + +O *Index* é a camada da interface no git. É o elemento que separa +o diretório do projeto do repositório git. Isto permite aos programadores um +maior controle sobre o que é registado no repositório git. + +### *Commit* + +Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto. +Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações +serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado +para outros repositórios ou não! + +### *Branch* + +Um *branch* é essencialmente uma referência que aponta para o último *commit* +efetuado. Na medida que são feitos novos commits, esta referência é atualizada +automaticamente e passa a apontar para o commit mais recente. + +### *HEAD* e *head* (componentes do diretório .git) + +*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem +uma *HEAD* activa. +*head* é uma referência que aponta para qualquer *commit*. Um repositório pode +ter um número indefinido de *heads* + +### Recursos conceituais (EN) + +* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/) +* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html) + +## Comandos + +### *init* + +Cria um repositório Git vazio. As definições, informação guardada e outros do +repositório git são guardados em uma pasta chamada ".git". + +```bash +$ git init +``` + +### *config* + +Permite configurar as definições, sejam as definições do repositório, sistema +ou configurações globais. + +```bash +# Imprime e define algumas variáveis de configuração básicas (global) +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config) + +### help + +Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica. + +```bash +# Ver rapidamente os comandos disponiveis +$ git help + +# Ver todos os comandos disponiveis +$ git help -a + +# Usar o *help* para um comando especifico +# git help <comando_aqui> +$ git help add +$ git help commit +$ git help init +``` + +### status + +Apresenta as diferenças entre o arquivo *index* (a versão corrente +do repositório) e o *commit* da *HEAD* atual. + + +```bash +# Apresenta o *branch*, arquivos não monitorados, alterações e outras +# difereças +$ git status + +# Para aprender mais detalhes sobre git *status* +$ git help status +``` + +### add + +Adiciona arquivos ao repositório corrente. Se os arquivos novos não forem +adicionados através de `git add` ao repositório, então eles não serão +incluidos nos commits! + +```bash +# adiciona um arquivo no diretório do projeto atual +$ git add HelloWorld.java + +# adiciona um arquivo num sub-diretório +$ git add /path/to/file/HelloWorld.c + +# permite usar expressões regulares! +$ git add ./*.java +``` + +### branch + +Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este +comando. + +```bash +# listar *branches* existentes e remotos +$ git branch -a + +# criar um novo *branch* +$ git branch myNewBranch + +# apagar um *branch* +$ git branch -d myBranch + +# alterar o nome de um *branch* +# git branch -m <oldname> <newname> +$ git branch -m myBranchName myNewBranchName + +# editar a descrição de um *branch* +$ git branch myBranchName --edit-description +``` + +### checkout + +Atualiza todos os arquivos no diretório do projeto para que fiquem iguais +à versão do index ou do *branch* especificado. + +```bash +# Checkout de um repositório - por padrão para o branch master +$ git checkout +# Checkout de um branch especifico +$ git checkout branchName +# Cria um novo branch e faz checkout para ele. +# Equivalente a: "git branch <name>; git checkout <name>" +$ git checkout -b newBranch +``` + +### clone + +Clona ou copia um repositório existente para um novo diretório. Também +adiciona *branches* de monitoramento remoto para cada *branch* no repositório +clonado o que permite enviar alterações para um *branch* remoto. + +```bash +# Clona learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git +``` + +### commit + +Guarda o conteudo atual do index num novo *commit*. Este *commit* contém +as alterações feitas e a mensagem criada pelo usuário. + +```bash +# commit com uma mensagem +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +``` + +### diff + +Apresenta as diferenças entre um arquivo no repositório do projeto, *index* +e *commits* + +```bash +# Apresenta a diferença entre o diretório atual e o index +$ git diff + +# Apresenta a diferença entre o index e os commits mais recentes +$ git diff --cached + +# Apresenta a diferença entre o diretório atual e o commit mais recente +$ git diff HEAD +``` + +### grep + +Permite procurar facilmente num repositório + +Configurações opcionais: + +```bash +# Define a apresentação de números de linha nos resultados do grep +$ git config --global grep.lineNumber true + +# Agrupa os resultados da pesquisa para facilitar a leitura +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Pesquisa por "variableName" em todos os arquivos java +$ git grep 'variableName' -- '*.java' + +# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove" +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +O Google é seu amigo; para mais exemplos: +[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Apresenta commits do repositório. + +```bash +# Apresenta todos os commits +$ git log + +# Apresenta X commits +$ git log -n 10 + +# Apresenta apenas commits de merge +$ git log --merges +``` + +### merge + +"Merge" junta as alterações de commits externos com o *branch* atual. + +```bash +# Junta o branch especificado com o atual +$ git merge branchName + +# Para gerar sempre um commit ao juntar os branches +$ git merge --no-ff branchName +``` + +### mv + +Alterar o nome ou mover um arquivo. + +```bash +# Alterar o nome de um arquivo +$ git mv HelloWorld.c HelloNewWorld.c + +# Mover um arquivo +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Forçar a alteração de nome ou mudança local +# "existingFile" já existe no directório, será sobrescrito. +$ git mv -f myFile existingFile +``` + +### pull + +Puxa alterações de um repositório e as junta com outro branch + +```bash +# Atualiza o repositório local, juntando as novas alterações +# do repositório remoto 'origin' e branch 'master' +# git pull <remote> <branch> +# git pull => aplica a predefinição => git pull origin master +$ git pull origin master + +# Juntar alterações do branch remote e fazer rebase commits do branch +# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>" +$ git pull origin master --rebase +``` + +### push + +Enviar e juntar alterações de um branch para o seu branch correspondente +num repositório remoto. + +```bash +# Envia e junta as alterações de um repositório local +# para um remoto denominado "origin" no branch "master". +# git push <remote> <branch> +# git push => aplica a predefinição => git push origin master +$ git push origin master +``` + +### rebase (cautela!) + +Pega em todas as alterações que foram registadas num branch e volta a +aplicá-las em outro branch. +*Não deve ser feito rebase de commits que foram enviados para um repositório +público* + +```bash +# Faz Rebase de experimentBranch para master +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (cuidado!) + +Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*, +*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também +perigoso quando não há certeza do que se está fazendo. + +```bash +# Restabelece a camada intermediária de registo para o último +# commit (o directório fica sem alterações) +$ git reset + +# Restabelece a camada intermediária de registo para o último commit, e +# sobrescreve o projeto atual +$ git reset --hard + +# Move a head do branch atual para o commit especificado, sem alterar o projeto. +# todas as alterações ainda existem no projeto +$ git reset 31f2bb1 + +# Inverte a head do branch atual para o commit especificado +# fazendo com que este esteja em sintonia com o diretório do projeto +# Remove alterações não registadas e todos os commits após o commit especificado +$ git reset --hard 31f2bb1 +``` + +### rm + +O oposto de git add, git rm remove arquivos do branch atual. + +```bash +# remove HelloWorld.c +$ git rm HelloWorld.c + +# Remove um arquivo de um sub-directório +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## Informação complementar (EN) + +* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) + +* [git-scm - Video Tutorials](http://git-scm.com/videos) + +* [git-scm - Documentation](http://git-scm.com/docs) + +* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown new file mode 100644 index 00000000..c7339831 --- /dev/null +++ b/pt-br/go-pt.html.markdown @@ -0,0 +1,312 @@ +--- +name: Go +category: language +language: Go +filename: learngo-pt.go +lang: pt-br +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] +translators: + - ["Nuno Antunes", "https://github.com/ntns"] +--- + +A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não +é a última moda em ciências da computação, mas é a mais recente e mais rápida +forma de resolver os problemas do mundo real. + +Tem conceitos familiares de linguagens imperativas com tipagem estática. É +rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência +fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem +recursos para ajudar com a programação em larga escala. + +Go vem com uma biblioteca padrão exaustiva e uma comunidade entusiasta. + +```go +// Comentário de uma linha +/* Comentário de + várias linhas */ + +// A cláusula package aparece no início de cada arquivo. +// Main é um nome especial declarando um executável ao invés de uma biblioteca. +package main + +// A cláusula Import declara os pacotes referenciados neste arquivo. +import ( + "fmt" // Um pacote da biblioteca padrão da linguagem Go + "net/http" // Sim, um servidor web! + "strconv" // Conversão de Strings +) + +// Definição de uma função. Main é especial. É o ponto de entrada para o +// programa executável. Goste-se ou não, a linguagem Go usa chavetas. +func main() { + // A função Println envia uma linha para stdout. + // É necessário qualifica-la com o nome do pacote, fmt. + fmt.Println("Olá Mundo!") + + // Chama outra função dentro deste pacote. + beyondHello() +} + +// As funções declaram os seus parâmetros dentro de parênteses. Se a função +// não receber quaisquer parâmetros, é obrigatório usar parênteses vazios. +func beyondHello() { + var x int // Declaração de variável. Tem de ser declarada antes de usar. + x = 3 // Atribuição de variável. + // Declarações "curtas" usam := para inferir o tipo, declarar e atribuir. + y := 4 + sum, prod := learnMultiple(x, y) // a função retorna dois valores + fmt.Println("soma:", sum, "produto:", prod) + learnTypes() // continuar a aprender! +} + +// As funções podem receber parâmetros e retornar (vários!) valores. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // retorna dois valores +} + +// Alguns tipos e literais básicos. +func learnTypes() { + // Declarações "curtas" geralmente servem para o que pretendemos. + s := "Aprender Go!" // tipo string + + s2 := `Uma string em "bruto" +pode incluir quebras de linha.` // mesmo tipo string + + // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8. + g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode + + f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754) + c := 3 + 4i // complex128, representado internamente com dois float64s + + // Declaração de variáveis, com inicialização. + var u uint = 7 // inteiro sem sinal, tamanho depende da implementação do Go + var pi float32 = 22. / 7 + + // Sintaxe de conversão de tipo, com declaração "curta". + n := byte('\n') // byte é um alias para uint8 + + // Os arrays têm tamanho fixo e definido antes da compilação. + var a4 [4]int // um array de 4 ints, inicializado com ZEROS + a3 := [...]int{3, 1, 5} // um array de 3 ints, inicializado como mostrado + + // As slices têm tamanho dinâmico. Os arrays e as slices têm cada um as + // suas vantagens mas o uso de slices é muito mais comum. + s3 := []int{4, 5, 9} // compare com a3. sem reticências aqui + s4 := make([]int, 4) // aloca uma slice de 4 ints, inicializada com ZEROS + var d2 [][]float64 // declaração apenas, nada é alocado + bs := []byte("uma slice") // sintaxe de conversão de tipos + + p, q := learnMemory() // learnMemory retorna dois apontadores para int. + fmt.Println(*p, *q) // * segue um apontador. isto imprime dois ints. + + // Os maps são um tipo de matriz associativa, semelhante aos tipos hash + // ou dictionary que encontramos noutras linguagens. + m := map[string]int{"três": 3, "quatro": 4} + m["um"] = 1 + + // As variáveis não usadas são um erro em Go. + // O traço inferior permite "usar" uma variável, mas descarta o seu valor. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Enviar para o stdout conta como utilização de uma variável. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() +} + +// A linguagem Go é totalmente garbage collected. Tem apontadores mas não +// permite que os apontadores sejam manipulados com aritmética. Pode-se cometer +// um erro com um apontador nulo, mas não por incrementar um apontador. +func learnMemory() (p, q *int) { + // A função retorna os valores p e q, que são do tipo apontador para int. + p = new(int) // a função new aloca memória, neste caso para um int. + // O int alocado é inicializado com o valor 0, p deixa de ser nil. + s := make([]int, 20) // alocar 20 ints como um único bloco de memória + s[3] = 7 // atribui o valor 7 a um deles + r := -2 // declarar outra variável local + return &s[3], &r // & obtém o endereço de uma variável. +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // As instruções if exigem o uso de chavetas, e não requerem parênteses. + if true { + fmt.Println("eu avisei-te") + } + // A formatação do código-fonte é "estandardizada" através do comando + // da linha de comandos "go fmt." + if false { + // reclamar + } else { + // exultar + } + // Preferir o uso de switch em vez de ifs em cadeia. + x := 1 + switch x { + case 0: + case 1: + // os cases não fazem "fall through" + case 2: + // esta linha só é executada se e só se x=2 + } + // Tal como a instrução if, a instrução for não usa parênteses. + for x := 0; x < 3; x++ { // x++ é uma instrução, nunca uma expressão + fmt.Println("iteração", x) + } + // note que, x == 1 aqui. + + // A instrução for é a única para ciclos, mas assume várias formas. + for { // ciclo infinito + break // brincadeirinha + continue // nunca executado + } + // O uso de := numa instrução if permite criar uma variável local, + // que existirá apenas dentro do bloco if. + if y := expensiveComputation(); y > x { + x = y + } + // As funções podem ser closures. + xBig := func() bool { + return x > 100 // referencia x, declarado acima da instrução switch. + } + fmt.Println("xBig:", xBig()) // true (1e6 é o último valor de x) + x /= 1e5 // agora temos x == 10 + fmt.Println("xBig:", xBig()) // false + + // Quando for mesmo necessário, pode usar o velho goto. + goto love +love: + + learnInterfaces() // Mais coisas interessantes chegando! +} + +// Define Stringer como uma interface consistindo de um método, String. +type Stringer interface { + String() string +} + +// Define pair como uma struct com dois campos ints chamados x e y. +type pair struct { + x, y int +} + +// Define um método para o tipo pair. O tipo pair implementa agora a +// interface Stringer. +func (p pair) String() string { // p é chamado de "receptor" + // Sprintf é outra função pública no pacote fmt. + // Uso de pontos para referenciar os campos de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Uma struct pode ser inicializada com os valores dos seus campos dentro + // de chavetas, seguindo a mesma ordem com que os campos foram definidos. + p := pair{3, 4} + fmt.Println(p.String()) // chama o método String de p, que tem tipo pair. + var i Stringer // declara i do tipo interface Stringer. + i = p // válido, porque pair implementa Stringer + // Chama o método String de i, que tem tipo Stringer. Mesmo que acima. + fmt.Println(i.String()) + + // As funções no pacote fmt chamam o método String para pedir a um objecto + // uma representação textual de si mesmo. + fmt.Println(p) // mesmo que acima. Println chama o método String. + fmt.Println(i) // mesmo que acima. + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" forma idiomática usada para saber se algo funcionou ou não. + m := map[int]string{3: "três", 4: "quatro"} + if x, ok := m[1]; !ok { // ok vai ser false porque 1 não está no map m. + fmt.Println("ninguem lá") + } else { + fmt.Print(x) // x seria o valor, se 1 estivesse no map. + } + // Um valor de erro comunica mais informação sobre o problema. + if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta o valor + // imprime "strconv.ParseInt: parsing "non-int": invalid syntax" + fmt.Println(err) + } + // Vamos revisitar as interfaces um pouco mais tarde. Entretanto, + learnConcurrency() +} + +// c é um channel, um objecto para comunicação concurrency-safe. +func inc(i int, c chan int) { + c <- i + 1 // <- é operador "enviar" quando um channel aparece à esquerda. +} + +// Vamos usar a função inc para incrementar números de forma concorrente. +func learnConcurrency() { + // A mesma função make usada anteriormente para alocar uma slice. + // Make aloca e inicializa slices, maps, e channels. + c := make(chan int) + // Inicia três goroutines concorrentes. Os números serão incrementados de + // forma concorrente, talvez em paralelo se a máquina for capaz e estiver + // configurada correctamente. As três goroutines enviam para o mesmo canal. + go inc(0, c) // go é a instrução para iniciar uma goroutine. + go inc(10, c) + go inc(-805, c) + // Lê três resultados do channel c e imprime os seus valores. + // Não se pode dizer em que ordem os resultados vão chegar! + fmt.Println(<-c, <-c, <-c) // channel na direita, <- é operador "receptor". + + cs := make(chan string) // outro channel, este lida com strings. + cc := make(chan chan string) // channel que lida com channels de strings. + go func() { c <- 84 }() // inicia uma goroutine para enviar um valor + go func() { cs <- "palavroso" }() // outra vez, para o channel cs desta vez + // A instrução select tem uma sintaxe semelhante à instrução switch mas + // cada caso envolve uma operação com channels. Esta instrução seleciona, + // de forma aleatória, um caso que esteja pronto para comunicar. + select { + case i := <-c: // o valor recebido pode ser atribuído a uma variável + fmt.Printf("é um %T", i) + case <-cs: // ou o valor recebido pode ser descartado + fmt.Println("é uma string") + case <-cc: // channel vazio, não se encontra pronto para comunicar. + fmt.Println("não aconteceu") + } + // Neste ponto um valor foi recebido de um dos channels c ou cs. Uma das + // duas goroutines iniciadas acima completou, a outra continua bloqueada. + + learnWebProgramming() // Go faz. Você quer faze-lo também. +} + +// Basta apenas uma função do pacote http para iniciar um servidor web. +func learnWebProgramming() { + // O primeiro parâmetro de ListenAndServe é o endereço TCP onde escutar. + // O segundo parâmetro é uma interface, especificamente http.Handler. + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // não ignorar erros +} + +// Tornar pair um http.Handler ao implementar o seu único método, ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Servir dados com um método de http.ResponseWriter + w.Write([]byte("Aprendeu Go em Y minutos!")) +} +``` + +## Leitura Recomendada + +A principal fonte de informação é o [web site oficial Go](http://golang.org/). +Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito. + +A própria especificação da linguagem é altamente recomendada. É fácil de ler e +incrivelmente curta (em relação ao que é habitual hoje em dia). + +Na lista de leitura para os aprendizes de Go deve constar o [código fonte da +biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é +a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da +sua escrita idiomática. Ou então clique no nome de uma função na [documentação] +(http://golang.org/pkg/) e veja o código fonte aparecer! + +Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/). +Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre +a linguagem. diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown new file mode 100644 index 00000000..2ec7d967 --- /dev/null +++ b/pt-br/groovy-pt.html.markdown @@ -0,0 +1,435 @@ +--- +language: Groovy +category: language +filename: learngroovy.groovy +contributors: + - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"] +translators: + - ["João Farias", "https://github.com/JoaoGFarias"] +lang: pt-br +--- + +Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://www.groovy-lang.org/) + +```groovy + +/* + Prepara-se: + + 1) Instale a máquina virtual de Groovy - http://gvmtool.net/ + 2) Intalse o Groovy: gvm install groovy + 3) Inicie o console groovy digitando: groovyConsole + +*/ + +// Comentário de uma linha inicia-se com duas barras +/* +Comentário de múltiplas linhas são assim. +*/ + +// Olá Mundo! +println "Olá mundo!" + +/* + Variáveis: + + Você pode atribuir valores a variáveis para uso posterior +*/ + +def x = 1 +println x + +x = new java.util.Date() +println x + +x = -3.1499392 +println x + +x = false +println x + +x = "Groovy!" +println x + +/* + Coleções e mapeamentos +*/ + +//Criando uma lista vazia +def tecnologias = [] + +/*** Adicionando elementos à lista ***/ + +// Assim como Java +tecnologias.add("Grails") + +// Shift para esquerda adiciona e retorna a lista +tecnologias << "Groovy" + +// Adição de múltiplos elementos +tecnologias.addAll(["Gradle","Griffon"]) + +/*** Removendo elementos da lista ***/ + +// Assim como Java +tecnologias.remove("Griffon") + +// Subtração também funciona +tecnologias = technologies - 'Grails' + +/*** Iterando sobre listas ***/ + +// Itera sobre os elementos da lista +tecnologias.each { println "Tecnologias: $it"} +tecnologias.eachWithIndex { it, i -> println "$i: $it"} + +/*** Checando os elementos da lista ***/ + +//Avalia se a lista contém o elemento 'Groovy' +contem = tecnologias.contains( 'Groovy' ) + +// Ou +contem = 'Groovy' in tecnologias + +// Checagem por múltiplos elementos +tecnologias.containsAll(['Groovy','Grails']) + +/*** Ordenando listas ***/ + +// Ordena a lista (altera a lista in-place) +tecnologias.sort() + +// Para ordenar a lista sem alterar a original +tecnologiasOrdenadas = tecnologias.sort( false ) + +/*** Manipulando listas ***/ + +//Substitue todos os elementos da lista +Collections.replaceAll(tecnologias, 'Gradle', 'gradle') + +//Desorganiza a lista +Collections.shuffle(tecnologias, new Random()) + +//Limpa a lista +technologies.clear() + +//Criando um mapeamento vazio +def devMap = [:] + +//Adicionando valores +devMap = ['nome':'Roberto', 'framework':'Grails', 'linguagem':'Groovy'] +devMap.put('ultimoNome','Perez') + +//Iterando sobre os elementos do mapeamento +devMap.each { println "$it.key: $it.value" } +devMap.eachWithIndex { it, i -> println "$i: $it"} + +//Avalia se um mapeamento contém uma chave +assert devMap.containsKey('nome') + +//Avalia se um mapeamento contém um valor +assert devMap.containsValue('Roberto') + +//Pega as chaves de um mapeamento +println devMap.keySet() + +//Pega os valores de um mapeamento +println devMap.values() + +/* + Groovy Beans + + GroovyBeans são JavaBeans com uma sintaxe muito mais simples. + + Quando Groovy é compilado para bytecode, as seguintes regras são usadas: + + * Se o nome é declarado com um modificador de acesso(public, private or + protected) então um atributo é gerado. + + * Um nome declarado sem modificador de acesso gera um campo privado com + getter e setter públicos (ou seja, uma propriedade). + + * Se uma propriedade é declarada como final, um campo private final é criado + e o setter não é gerado. + + * Você pode declarar uma propriedade e também declarar seus próprios getters + e setters. + + * Você pode declarar uma propriedade e um campo com o mesmo nome, a propriedade + usará este campo. + + * Se você quer uma propriedade private ou protected, você deve prover seus + próprios getters e setter, que devem ser declarados como private ou protected. + + * Se você acessar uma propriedade dentro da classe e esta propriedade é definida + em tempo de compilação com 'this', implícito ou explícito (por exemplo, + this.foo, ou simplesmente foo), Groovy acessará este campo diretamente, sem + passar pelo getter ou setter. + + * Se você acessar uma propriedade que não existe usando foo, explicitamente ou + implicitamente, então Groovy irá acessar esta propriedade através da meta + classe, o que pode falhar em tempo de execução. + +*/ + +class Foo { + // propriedade de leitura, apenas + final String nome = "Roberto" + + // propriedade de leitura, apenas, com getter e setter públicos + String linguagem + protected void setLinguagem(String linguagem) { this.linguagem = linguagem } + + // propriedade tipada dinamicamente + def ultimoNome +} + +/* + Condicionais e loops +*/ + +//Groovy suporta a sintaxe if-else +def x = 3 + +if(x==1) { + println "Um" +} else if(x==2) { + println "Dois" +} else { + println "X é maior que Dois" +} + +//Groovy também suporta o operador ternário +def y = 10 +def x = (y > 1) ? "functionou" : "falhou" +assert x == "functionou" + +//Loop 'for' +//Itera sobre um intervalo (range) +def x = 0 +for (i in 0 .. 30) { + x += i +} + +//Itera sobre uma lista +x = 0 +for( i in [5,3,2,1] ) { + x += i +} + +//Itera sobre um array +array = (0..20).toArray() +x = 0 +for (i in array) { + x += i +} + +//Itera sobre um mapa +def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] +x = 0 +for ( e in map ) { + x += e.value +} + +/* + Operadores + + Sobrecarregamento de Operadores para uma lsita dos operadores comuns que + Grooby suporta: + http://www.groovy-lang.org/operators.html#Operator-Overloading + + Operadores Groovy úteis +*/ +//Operador de espalhamento: invoca uma ação sobre todos os itens de um +//objeto agregador. +def tecnologias = ['Groovy','Grails','Gradle'] +tecnologias*.toUpperCase() // = to tecnologias.collect { it?.toUpperCase() } + +//Operador de navegação segura: usado para evitar NullPointerException. +def usuario = User.get(1) +def nomeUsuario = usuario?.nomeUsuario + + +/* + Closures + Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método. + É um pedação de código que é definido e executado em um momento posterior. + + Mais informação em: http://www.groovy-lang.org/closures.html +*/ +//Exemplo: +def clos = { println "Hello World!" } + +println "Executando o closure:" +clos() + +//Passando parêmetros para um closure +def soma = { a, b -> println a+b } +soma(2,4) + +//Closdures por referir-se a variáveis que não estão listadas em sua +//lista de parêmetros. +def x = 5 +def multiplicarPor = { num -> num * x } +println multiplicarPor(10) + +// Se você tiver um closure que tem apenas um argumento, você pode omitir +// o parâmetro na definição do closure +def clos = { print it } +clos( "oi" ) + +/* + Groovy pode memorizar resultados de closures [1][2][3] +*/ +def cl = {a, b -> + sleep(3000) // simula processamento + a + b +} + +mem = cl.memoize() + +def chamaClosure(a, b) { + def inicio = System.currentTimeMillis() + mem(a, b) + println "Os inputs(a = $a, b = $b) - tomam ${System.currentTimeMillis() - inicio} msecs." +} + +chamaClosure(1, 2) +chamaClosure(1, 2) +chamaClosure(2, 3) +chamaClosure(2, 3) +chamaClosure(3, 4) +chamaClosure(3, 4) +chamaClosure(1, 2) +chamaClosure(2, 3) +chamaClosure(3, 4) + +/* + Expando + + A classe Expando é um bean dinâmico que permite adicionar propriedade e + closures como métodos a uma instância desta classe + + http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html +*/ + def usuario = new Expando(nome:"Roberto") + assert 'Roberto' == nome.name + + nome.lastName = 'Pérez' + assert 'Pérez' == nome.lastName + + nome.showInfo = { out -> + out << "Name: $name" + out << ", Last name: $lastName" + } + + def sw = new StringWriter() + println nome.showInfo(sw) + + +/* + Metaprogramação (MOP) +*/ + +//Usando a ExpandoMetaClasse para adicionar comportamento +String.metaClass.testAdd = { + println "adicionamos isto" +} + +String x = "teste" +x?.testAdd() + +//Interceptando chamadas a métodos +class Test implements GroovyInterceptable { + def soma(Integer x, Integer y) { x + y } + + def invocaMetodo(String name, args) { + System.out.println "Invoca método $name com argumentos: $args" + } +} + +def teste = new Test() +teste?.soma(2,3) +teste?.multiplica(2,3) + +//Groovy suporta propertyMissing para lidar com tentativas de resolução de +//propriedades. +class Foo { + def propertyMissing(String nome) { nome } +} +def f = new Foo() + +assertEquals "boo", f.boo + +/* + TypeChecked e CompileStatic + Groovy, por natureza, é e sempre será uma linguagem dinâmica, mas ela também + suporta typecheked e compilestatic + + Mais informações: http://www.infoq.com/articles/new-groovy-20 +*/ +//TypeChecked +import groovy.transform.TypeChecked + +void testeMethod() {} + +@TypeChecked +void test() { + testeMethod() + + def nome = "Roberto" + + println noomee + +} + +//Outro exemplo: +import groovy.transform.TypeChecked + +@TypeChecked +Integer test() { + Integer num = "1" + + Integer[] numeros = [1,2,3,4] + + Date dia = numeros[1] + + return "Teste" + +} + +//Exemplo de CompileStatic : +import groovy.transform.CompileStatic + +@CompileStatic +int soma(int x, int y) { + x + y +} + +assert soma(2,5) == 7 + + +``` + +## Referências + +[Groovy documentation](http://www.groovy-lang.org/documentation.html) + +[Groovy web console](http://groovyconsole.appspot.com/) + +Junte-se a um [grupo de usuários Groovy](http://www.groovy-lang.org/usergroups.html) + +## Livro + +* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook) + +* [Groovy in Action] (http://manning.com/koenig2/) + +* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do) + +[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/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 +<?hh + +// A sintaxe do Hack é ativada apenas em arquivos que comecem com <?hh +// Marcadores <?hh não podem ser incluídos em páginas HTML, diferente de <?php. +// Usar o marcador "<?hh //strict" coloca o verificador de tipo no modo estrito. + + +// Indução de tipo de parâmetros escalares +function repeat(string $palavra, int $contagem) +{ + $palavra = trim($palavra); + return str_repeat($palavra . ' ', $contagem); +} + +// Indução de tipo para valores de retorno +function add(...$numeros) : int +{ + return array_sum($numeros); +} + +// Funções que não retornam nada são induzidas com "void" +function truncate(resource $recurso) : void +{ + // ... +} + +// Induções de tipo devem permitir nulos de forma explícita +function identity(?string $stringOuNulo) : ?string +{ + return $stringOuNulo; +} + +// Induções de tipo podem ser especificadas em propriedades de classes +class PropriedadesComTipos +{ + public ?string $nome; + + protected int $id; + + private float $pontuacao = 100.0; + + // O verificador de tipos do Hack reforça que propriedades tipadas devem + // ter um valor padrão ou devem ser definidos no construtor + public function __construct(int $id) + { + $this->id = $id; + } +} + + +// Funções anônimas (lambdas) +$multiplicador = 5; +array_map($y ==> $y * $multiplicador, [1, 2, 3]); + + +// Genéricos +class Caixa<T> +{ + protected T $dados; + + public function __construct(T $dados) { + $this->dados = $dados; + } + + public function pegaDados(): T { + return $this->dados; + } +} + +function abreCaixa(Caixa<int> $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<int, Vector<int>>; + +// 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<void> +{ + 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-<?hh" + // + <<__Override>> + 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/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown new file mode 100644 index 00000000..788dc1d2 --- /dev/null +++ b/pt-br/haskell-pt.html.markdown @@ -0,0 +1,620 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Lucas Tonussi", "http://www.inf.ufsc.br/~tonussi/"] +lang: pt-br +filename: learnhaskell-pt.hs +--- + +As linguagens funcionais são linguagens de programação com base em avaliação +de funções matemáticas (expressões), evitando-se o conceito de mudança de +estado com alteração de dados. Neste aspecto, este paradigma é oposto ao +paradigma imperativo que se baseia em alterações de estados. + +A programação funcional começou no cálculo lambda, que foi base teórica para +o desenvolvimento deste paradigma de programação. + + +```haskell +-- Para comentar a linha basta dois traços seguidos. + +{- Abre chaves traço e traço fecha chaves cria um campo + para comentário em múltiplas linhas. +-} + +---------------------------------------------------- +-- 1. Tipos Primitivos de Dados e Operadores +---------------------------------------------------- + +-- Numerais + +0 -- 3 +1 -- 1 +2 -- 2 ... + +-- Alguns Operadores Fundamentais + +7 + 7 -- 7 mais 7 +7 - 7 -- 7 menos 7 +7 * 7 -- 7 vezes 7 +7 / 7 -- 7 dividido por 7 + +-- Divisões não são inteiras, são fracionádas por padrão da linguagem +28736 / 82374 -- 0.3488479374559934 + + +-- Divisão inteira +82374 `div` 28736 -- 2 + +-- Divisão modular +82374 `mod` 28736 -- 24902 + +-- Booleanos como tipo primitivo de dado +True -- Verdadeiro +False -- Falso + +-- Operadores unitário +not True -- Nega uma verdade +not False -- Nega uma falácia + + +-- Operadores binários +7 == 7 -- 7 é igual a 7 ? +7 /= 7 -- 7 é diferente de 7 ? +7 < 7 -- 7 é menor que 7 ? +7 > 7 -- 7 é maior que 7 ? + + +{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na + matemática, por exemplo em chamadas de funções você tem: + + NomeFunção ArgumentoA ArgumentoB ArgumentoC ... +-} + +-- Strings e Caractéres +"Texto entre abre áspas e fecha áspas define uma string" +'a' -- Caractere +'A' -- Caractere + +'Strings entre aspas simples sobe um erro' -- Erro léxico! + +-- Concatenação de Strings +"StringA" ++ "StringB" -- "StringAStringB" + +-- Concatenação de Caracteres +"haskell" == ['h','a','s','k','e','l','l'] -- True +"haskell" == 'h':'a':'s':'k':'e':'l':'l':[] -- True + +-- Você pode listar uma string pelos seus caractéres +"AbBbbcAbbcbBbcbcb" !! 0 -- 'A' +"AbBbbcAbbcbBbcbcb" !! 1 -- 'b' +"AbBbbcAbbcbBbcbcb" !! 2 -- 'B' + +---------------------------------------------------- +-- Listas e Túplas +---------------------------------------------------- + +-- A construção de uma lista precisa ser de elementos homogêneos +[1, 2, 3, 4, 5] -- Homogênea +[1, a, 2, b, 3] -- Heterogênea (Erro) + +-- Haskell permite que você crie sequências +[1..5] + +{- Haskell usa avaliação preguiçosa o que + permite você ter listas "infinitas". +-} + +-- Uma lista "infinita" cuja razão é 1 +[1..] + +-- O 777º elemento de uma lista de razão 1 +[1..] !! 777 -- 778 + +-- União de listas [lista_0] ++ [lista_1] ++ [lista_i] +[1..5] ++ [6..10] ++ [1..4] -- [1,2,3,4,5,6,7,8,9,10,1,2,3,4] + +-- Adiciona um cabeçalho a sua lista e desloca a cauda +0:[1..10] -- [0, 1, 2, 3, 4, 5] +'a':['a'..'e'] -- "aabcde" + +-- Indexação em uma lista +[0..] !! 5 -- 5 + +-- Operadores de Listas usuais +head ['a'..'e'] -- Qual o cabeçalho da lista ? +tail ['a'..'e'] -- Qual a cauda da lista ? +init ['a'..'e'] -- Qual a lista menos o último elemento ? +last ['a'..'e'] -- Qual o último elemento ? + +-- Compreensão de Lista (List Comprehension) + +{- Uma lista pode ser especificada + pela definição de eus elementos. + A compreensão de listas é feita + com um construtor de listas que + utiliza conceitos e notações + da teoria dos conjuntos. + + Exemplo: + + A = { x**2 | X pertence aos Naturais && x é par} +-} + +let par x = mod x 2 == 0 +let constroi_lista = [x * x | x <- [9 ..39], par x] +-- [100,144,196,256,324,400,484,576,676,784,900,1024,1156,1296,1444] + +par 4 -- True +par 3 -- False + + +-- Listas com regras +{- Para todo x se x é elemento da lista + faça 2 vezes x mas componha a lista + com apenas aqueles elementos cujo + 2*x é maior que 4 +-} +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Tuplas +("Q", "Gamma", "b", "Sigma", "delta", "q0", "F") -- 7-Tuple Turing Machine + +-- Retirando da tupla + +{- Com as funções fst (primeiro) e snd (segundo) + você só pode enviar por parâmetro uma tupla + bi-dimensional ou seja, 2 dimensões == (x,y) +-} + +fst ((2,3), [2,3]) -- (2,3) +snd ((2,3), [4,3]) -- [4,3] + + +---------------------------------------------------- +-- 3. Funções em Haskell +---------------------------------------------------- + +-- Uma função simples que toma duas variáveis +{- Haskell trabalha em cima de recursão + Portanto certifique-se que você + Entende como recurssão funciona. +-} + +soma a b = a + b -- Função que vai em um programa.hs + +{- Dentro do GHCi (Interpretador Haskell) + Você terá que fazer da seguinte maneira-- Podemos criar nos + + Prelude> let soma a b = a + b + Prelude> soma 7 7 -- 14 +-} + +let constroi_lista = [x * x | x <- [9 ..39], par x] + +{- Você pode usar crases para chamar + Funcões de maneira diferente +-} + +7 `soma` 7 -- 14 + +{- Haskell permite que você crie os + seus próprios operadores baseados + nos já existendes +-} + +let (~/\) a b = a `mod` b +15^13 ~/\ 432 -- 759375 + +-- Casamento de Padrões em Tuplas +coordenadas (x, y) = (x + 13, y - 31) + +{- Haskell trabalha com casamento de padrões onde dada + um conjunto de funções definidas de diferentes maneiras + Haskell vai procurar por aquela que trabalha o seu tipo + de entrada. +-} + +-- Guardas "|" É um jeito simples de representar funções recursivas + +let fatorial n | n == 0 = 1 | otherwise = fatorial (n - 1) * n -- Teste: fatorial 5 + +-- Ainda podemos fazer: + +let fatorial 0 = 1 +let fatorial n = fatorial (n - 1) * n + +{- Podemos criar nossos próprios Mapeadores + Onde `primeiro` é o primeiro elemento de + uma lista é `resto` é o resto da lista. +-} + +mapa mapeador _ [] = [] +mapa mapeador (primeiro : resto) = mapeador primeiro : (mapa mapeador resto) + +{- Uma função anônima é uma função sem um nome. + É uma abstração do cálculo lambda: + + \x -> x + 1 + λ.x (x + 1) + + Em Haskell Barra Invertida é um jeito para + se escrever Lambda (λ). Uma ótima pedida + Para entender Haskell e outras linguagens como Lisp + É estudar Cálculo Lambda, é um entendimento matemático + mais apurado. E do ponto de vista computacional é + bastante interessante. Em EXTRAS você encontrará + Links para aprender Cálculo Lambda. +-} + +(\x -> x + 1) 4 -- 5 + + +{- Algumas vezes é mais conveniente usar expressões lambda + do que definir um nome para uma função. Na matemática + Nomes são muito simbólicos. Isso acontece bastante + quando você estiver trabalhando `map` ou `foldl` / `foldr` +-} + +-- Sem usar expressões anônimas ! +listaSomaUm lst = map somaUm' lst where somaUm' x = x + 1 + +-- Usando expressões anônimas ! +listaSomaUm' lst = map (\x -> x + 1) lst + +---------------------------------------------------- +-- 4. Mais Funções +---------------------------------------------------- + +{- Currying: Se você não passar todos os argumentos + para uma função, ela irá ser "currificada". O que + significa que irá retornar a função que pega o resto + dos elementos. +-} + +soma a b = a + b +foo = soma 10 -- foo ganha a propriedade "currying" +foo 5 -- 15 + +-- Outra maneira +foo = (+10) +foo 5 -- 15 + +{- Composição de Funções + O (.) encadeia funções! Por exemplo, + aqui foo é uma função que recebe um valor. + Ela soma 10 a ela, multiplica o resultado por 5 + e então retorna o resultado final. +-} +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + +{- Concertando precedência: + Haskell tem outra função chamada `$`. Isso altera a precedência + de computação. Ou seja Haskell computa o que está sendo sinalizado com $ + da esquerda para a direita . Você pode usar `.` e `$` para se livrar + de parentízação desnecessária. +-} + +(even (fatorial 3)) -- true + +-- Usando `.` e `$` +even . fatorial $ 3 -- true + +---------------------------------------------------- +-- 5. Tipos +---------------------------------------------------- + +-- Haskell é fortemente tipado e tudo tem uma assinatura típica. + +-- Tipos Básicos: +460 :: Integer +"music" :: String +True :: Bool + +{- Funções também tem tipos. + `not` recebe um booleano e retorna um booleano: + not :: Bool -> Bool +-} + +{- Aqui temos uma função que recebe dois argumentos + soma :: Integer -> Integer -> Integer +-} + +{- Quando você define um valor em Haskell + uma boa prática de programação é escrever + o TIPO acima dessa mesma. Como segue: +-} + +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. Controle de Fluxo e IF-THEN-ELSE +---------------------------------------------------- + +-- Blocos IF-THEN-ELSE +let valor_alternado = if 144 `mod` 6 == 4 then "acertou" else "errou" -- errou + +-- É legal identar quando você tem múltiplos branchs para acontecer + +let valor_alternado = if 144 `mod` 6 == 4 + then "acertou" + else "errou" + +-- Blocos CASE + +{- caso <argumento> seja : + <ajuda> -> mostra_ajuda + <inicia> -> inicia_programa + <_> -> putStrLn "ExArgumentoInvalido" + + Onde `_` Significa Qualquer Outra Coisa. +-} + + +case args of + "ajuda" -> mostra_ajuda + "inicia" -> inicia_programa + _ -> putStrLn "ExArgumentoInvalido" + +{- Haskell não funciona na base de loops pois ele é + fortemente baseado em funcões recursivas e cálculo lambda + + Use `map` uma função build-in do interpretador + para, por exemplo, mapear uma lista: +-} +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- Você pode criar um FOR-LOOP usando map +let for array funcao = map funcao array +for [0..5] $ \i -> show i + +-- Ou ainda (Pesquise sobre show em Haskell): +for [0..5] show + + +{- foldl computação é feita esquerda para direita + foldr computação é feita direita para esquerda + + Você pode usar foldl or foldr a fim de reduzir uma lista + fold(l||r) <funcao> <valor inicial> <lista> +-} + +-- Fold Left +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- Pensando Recursivamente Esquerda-Direita +(2 * (2 * (2 * 4 + 1) + 2) + 3) -- 43 + +-- Fold Right +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Pensando Recursivamente Direita-Esquerda +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. Declaração de Dados +---------------------------------------------------- + +{- Vamos começar definindo um tipo de + dado que é uma cor rgb então ela + tem valores para vermelho azul e verde + ela é composta desses 3 comprimentos + Vamos usar `data` e `say` que são built-in: + + Haskell pede que você user letra + maiuscula para tipos (types) ou classes (Class) + + Por favor, visite: http://www.haskell.org/haskellwiki/Type + E de uma olhada na fórmula genérica de declaração de dados. +-} + +data Cor = Vermelho | Azul | Verde + +-- say :: Color -> String + +let say Vermelho = "Vermelho" +let say Azul = "Azul" +let say Verde = "Verde" + +{- O seu tipo de dados por receber parâmetros também + vamos com um exemplo usando `data` e a Classe `Maybe`. +-} + +data Maybe a = Nothing | Just a + +-- Just e Nothing são todos derivadas de Maybe +Just "hello" -- tipo `Maybe String` +Just 1 -- tipo `Maybe Int` +Nothing -- tipo `Maybe a` para algum `a` + + +---------------------------------------------------- +-- 8. Mônadas +---------------------------------------------------- + +{- As mônadas permitem que o programador construa computações + sando os blocos de comando sequenciais, os quais, por sua vez, + podem ter outras sequencias de computações. Para entender melhor + a classe Monads você precisa ler um pouco mais sobre Classes em + Haskell e o polímofirmo ad hoc do Haskell. + + A Classe Mônada padrão em Haskell é a seguinte: +-} + +class Monad m where + (>>=) :: m a -> (a -> m b) -> m b + (>>) :: m a -> m b -> m b + return :: m -> m a + fail :: String -> m a + + -- Definição completa mínima: + -- (>>=), return + + m >> k = m >>= \_ -> k + fail s = error s + +{- Como exemplo, a função le_imprime opera com a função ">=" da + classe mônada, a qual repassa o retorno obtido com a função + getLine para uma função lambda \e qualquer. + + GHC-BASICS + Cria um arquivo chamado le_imprime.hs + compile: ghc --make -c -O Programa_Haskell_Principal.hs + execute: ./Programa_Haskell_Principal +-} + +le_imprime :: IO () +le_imprime = getLine >>= \e -> putStrLn e -- le_imprime = getLine >>= putStrLn + +{- Mônadas abrem a possibilidade de criar computações + no estilo imperativo dentro de um grande programa funcional + + Leis das Mônadas: + + 1. return a >>= k = k a + 2. m >>= return = m + 3. m >>= (\x -> k x >>= h) = (m >>= k) >>= h +-} + +-- O operador >> é chamada então (p -> q, p então q) +let m >> n = m >>= \_ -> n + + +---------------------------------------------------- +-- 9. Haskell Entrada/Saída +---------------------------------------------------- + +{- Quando um programa Haskell é executado a função `main` é + chamada. E ela precisa retornar um valor do tipo IO(). +-} + +module Main where + main :: IO () + main = putStrLn $ "Oi Glasgow!" + +-- Ou simplesmente: + +main = putStrLn $ "Oi Glasgow!" + +{- putStrLn é do tipo String -> IO() + + É o jeito mais fácil de conseguir E/S se você implementar + o seu programa como uma função de String para String. + + A função: + interact :: (String -> String) -> IO () + Joga texto, roda a função nela mesma, e imprime a saída +-} + +module Main where + contadorLinhas = show . length . lines + main = interact contadorLinhas + +-- Use a notação `do` para encadear ações. Por exemplo: + +diga_oi :: IO () + +diga_oi = do + + putStrLn "Qual eh o seu nome?" + name <- getLine + putStrLn $ "Oi, " ++ name + +main = diga_oi + +{- Exercício! Escreva sua própria versão + onde irá ler apenas uma linhas de input. + + Vamos entender melhor como `getLine` funciona? + getLine :: IO String + Pense que o valor do tipo `IO a` representando um + programa de computador que irá gerar um valor do tipo `a` + quando for ele executado. + + Nós podemos guardar e reusar isso apenas apontando `<-`. + Nós podemos também cria nossas próprias ações do tipo `IO String` +-} + +nova_acao :: IO String + +nova_acao = do + putStrLn "Uma string curta o bastante." + entra1 <- getLine + entra2 <- getLine + -- return :: String -> IO String + return (entra1 ++ "\n" ++ entra2) + +{- Nós podemos usar da seguinte maneira + como acabamos de usar `getLine`, exemplo: +-} + +main'' = do + putStrLn "String A" + result <- action + putStrLn result + putStrLn "String B" + +---------------------------------------------------- +-- 9. O Haskell REPL (Read Eval Print Loop) +---------------------------------------------------- + +{- Digite dhci no seu terminal + para começar o interpretador + lembre-se que para definir + funções e variáveis em haskell + pelo interpretador você precisar + iniciar com `let` +-} + +Prelude> let foo = 1.4 + +-- Você pode ver o tipo de algo usando `:t`: + +Prelude> :t foo +foo :: Double +``` + + +# Extra + +Compilador e Interpretador Haskell + +* [GHC](http://www.haskell.org/ghc/docs/latest/html/users_guide/index.html) +* [GHC/GHCi](http://www.haskell.org/haskellwiki/GHC) +* [Haskell em 5 Passos !!!](http://www.haskell.org/haskellwiki/Haskell_in_5_steps) + +Instale Haskell [Aqui!](http://www.haskell.org/platform/). + +Aplicações Haskell Muito Interessantes: + +* [Música e Som](http://www.haskell.org/haskellwiki/Applications_and_libraries/Music_and_sound) +* [Haskell SuperCollider Servidor](https://github.com/kaoskorobase/hsc3-server) +* [Haskell SuperCollider Cliente](http://hackage.haskell.org/package/hsc3) +* [Física e Matemática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Mathematics) +* [Jogos](http://www.haskell.org/haskellwiki/Applications_and_libraries/Games) +* [Bio Informática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Bioinformatics) +* [Muitos Outras Aplicações](http://www.haskell.org/haskellwiki/Libraries_and_tools) + +Comunidade Haskell +* [Musica das Mônadas](http://www.haskell.org/haskellwiki/Music_of_monads) +* [Entendendo Mônadas](https://en.wikibooks.org/wiki/Haskell/Understanding_monads) + +Tutoriais: + +* [Mapeadores](http://www.haskell.org/ghc/docs/6.12.2/html/libraries/containers-0.3.0.0/Data-Map.html) +* [Aprenda Haskell!](http://haskell.tailorfontela.com.br/chapters) +* [Fundação Teórica da Linguagem Haskell](http://www.haskell.org/haskellwiki/Lambda_calculus) +* [Classe Maybe](http://www.haskell.org/haskellwiki/Maybe) +* [Zvon Referência Haskell](http://www.zvon.org/other/haskell/) + +Obtenha Também Haskell Wiki Book [Aqui!](https://en.wikibooks.org/wiki/Haskell) + +Leia Sobre As Mônadas [Aqui!](http://www.haskell.org/haskellwiki/Monads) + +Livro: Haskell Uma Abordagem Prática - Claudio Cesar de Sá e Márcio Ferreira da Silva diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown new file mode 100644 index 00000000..4230579d --- /dev/null +++ b/pt-br/hy-pt.html.markdown @@ -0,0 +1,176 @@ +--- +language: hy +filename: learnhy.hy +contributors: + - ["Abhishek L", "http://twitter.com/abhishekl"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +Hy é um dialeto de Lisp escrito sobre Python. Isto é possível convertendo +código Hy em árvore sintática abstrata python (ast). Portanto, isto permite +hy chamar código python nativo e vice-versa. + +Este tutorial funciona para hy ≥ 0.9.12 + +```clojure +;; Isso dá uma introdução básica em hy, como uma preliminar para o link abaixo +;; http://try-hy.appspot.com +;; +; Comentários em ponto-e-vírgula, como em outros LISPS + +;; s-noções básicas de expressão +; programas Lisp são feitos de expressões simbólicas ou sexps que se assemelham +(some-function args) +; agora o essencial "Olá mundo" +(print "hello world") + +;; Tipos de dados simples +; Todos os tipos de dados simples são exatamente semelhantes aos seus homólogos +; em python que +42 ; => 42 +3.14 ; => 3.14 +True ; => True +4+10j ; => (4+10j) um número complexo + +; Vamos começar com um pouco de aritmética muito simples +(+ 4 1) ;=> 5 +; o operador é aplicado a todos os argumentos, como outros lisps +(+ 4 1 2 3) ;=> 10 +(- 2 1) ;=> 1 +(* 4 2) ;=> 8 +(/ 4 1) ;=> 4 +(% 4 2) ;=> 0 o operador módulo +; exponenciação é representado pelo operador ** como python +(** 3 2) ;=> 9 +; formas aninhadas vão fazer a coisa esperada +(+ 2 (* 4 2)) ;=> 10 +; também operadores lógicos e ou não e igual etc. faz como esperado +(= 5 4) ;=> False +(not (= 5 4)) ;=> True + +;; variáveis +; variáveis são definidas usando SETV, nomes de variáveis podem usar utf-8, exceto +; for ()[]{}",'`;#| +(setv a 42) +(setv π 3.14159) +(def *foo* 42) +;; outros tipos de dados de armazenamento +; strings, lists, tuples & dicts +; estes são exatamente os mesmos tipos de armazenamento de python +"hello world" ;=> "hello world" +; operações de string funcionam semelhante em python +(+ "hello " "world") ;=> "hello world" +; Listas são criadas usando [], a indexação começa em 0 +(setv mylist [1 2 3 4]) +; tuplas são estruturas de dados imutáveis +(setv mytuple (, 1 2)) +; dicionários são pares de valores-chave +(setv dict1 {"key1" 42 "key2" 21}) +; :nome pode ser utilizado para definir palavras-chave em hy que podem ser utilizados para as chaves +(setv dict2 {:key1 41 :key2 20}) +; usar 'get' para obter o elemento em um índice/key +(get mylist 1) ;=> 2 +(get dict1 "key1") ;=> 42 +; Alternativamente, se foram utilizadas palavras-chave que podem ser chamadas diretamente +(:key1 dict2) ;=> 41 + +;; funções e outras estruturas de programa +; funções são definidas usando defn, o último sexp é devolvido por padrão +(defn greet [name] + "A simple greeting" ; uma docstring opcional + (print "hello " name)) + +(greet "bilbo") ;=> "hello bilbo" + +; funções podem ter argumentos opcionais, bem como argumentos-chave +(defn foolists [arg1 &optional [arg2 2]] + [arg1 arg2]) + +(foolists 3) ;=> [3 2] +(foolists 10 3) ;=> [10 3] + +; funções anônimas são criados usando construtores 'fn' ou 'lambda' +; que são semelhantes para 'defn' +(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16] + +;; operações de sequência +; hy tem algumas utils embutidas para operações de sequência, etc. +; recuperar o primeiro elemento usando 'first' ou 'car' +(setv mylist [1 2 3 4]) +(setv mydict {"a" 1 "b" 2}) +(first mylist) ;=> 1 + +; corte listas usando 'slice' +(slice mylist 1 3) ;=> [2 3] + +; obter elementos de uma lista ou dict usando 'get' +(get mylist 1) ;=> 2 +(get mydict "b") ;=> 2 +; lista de indexação começa a partir de 0, igual em python +; assoc pode definir elementos em chaves/índices +(assoc mylist 2 10) ; faz mylist [1 2 10 4] +(assoc mydict "c" 3) ; faz mydict {"a" 1 "b" 2 "c" 3} +; há toda uma série de outras funções essenciais que torna o trabalho com +; sequências uma diversão + +;; Python interop +;; importação funciona exatamente como em python +(import datetime) +(import [functools [partial reduce]]) ; importa fun1 e fun2 do module1 +(import [matplotlib.pyplot :as plt]) ; fazendo uma importação em foo como em bar +; todos os métodos de python embutidas etc. são acessíveis a partir hy +; a.foo(arg) is called as (.foo a arg) +(.split (.strip "hello world ")) ;=> ["hello" "world"] + +;; Condicionais +; (if condition (body-if-true) (body-if-false) +(if (= passcode "moria") + (print "welcome") + (print "Speak friend, and Enter!")) + +; aninhe múltiplas cláusulas 'if else if' com cond +(cond + [(= someval 42) + (print "Life, universe and everything else!")] + [(> someval 42) + (print "val too large")] + [(< someval 42) + (print "val too small")]) + +; declarações de grupo com 'do', essas são executadas sequencialmente +; formas como defn tem um 'do' implícito +(do + (setv someval 10) + (print "someval is set to " someval)) ;=> 10 + +; criar ligações lexicais com 'let', todas as variáveis definidas desta forma +; tem escopo local +(let [[nemesis {"superman" "lex luther" + "sherlock" "moriarty" + "seinfeld" "newman"}]] + (for [(, h v) (.items nemesis)] + (print (.format "{0}'s nemesis was {1}" h v)))) + +;; classes +; classes são definidas da seguinte maneira +(defclass Wizard [object] + [[--init-- (fn [self spell] + (setv self.spell spell) ; init a mágica attr + None)] + [get-spell (fn [self] + self.spell)]]) + +;; acesse hylang.org +``` + +### Outras Leituras + +Este tutorial é apenas uma introdução básica para hy/lisp/python. + +Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org) + +Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy) + +Acesso ao freenode irc com #hy, hashtag no twitter: #hylang diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown new file mode 100644 index 00000000..a884f273 --- /dev/null +++ b/pt-br/java-pt.html.markdown @@ -0,0 +1,435 @@ +--- + +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Madison Dickson", "http://github.com/mix3d"] +translators: + - ["Victor Kléber Santos L. Melo", "http://victormelo.com.br/blog"] + - ["Renê Douglas N. de Morais", "mailto:rene.douglas.bsi@gmail.com"] +lang: pt-br +filename: LearnJava-pt.java + +--- + +Java é uma linguagem de programação de propósito geral, concorrente, baseada em classes e orientada a objetos. +[Leia mais aqui](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// Comentários de uma linha começam com // +/* +Comentários de várias linhas são feitos dessa forma. +*/ +/** +Comentários JavaDoc são feitos assim. São usados para descrever a Classe ou os atributos da Classe. +*/ + +// Importa a classe ArrayList que está dentro do pacote java.util +import java.util.ArrayList; +// Importa todas as classes que estão dentro do pacote java.security +import java.security.*; + +// Cada arquivo .java contém uma classe pública, com o mesmo nome do arquivo. +public class LearnJava { + + // Um programa precisa ter um método main como um ponto de entrada. + public static void main (String[] args) { + + // O System.out.println é usado para imprimir no console + System.out.println("Olá Mundo!"); + System.out.println( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Para imprimir sem inserir uma nova lina, use o System.out.print + System.out.print("Olá "); + System.out.print("Mundo"); + + + /////////////////////////////////////// + // Tipos & Variáveis + /////////////////////////////////////// + + // Declara-se variáveis usando <tipo> <nome> [ + // Byte - inteiro de 8 bits com sinal complementado a dois + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - inteiro de 16 bits com sinal complementado a dois + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - inteiro de 32 bits com sinal complementado a dois + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - inteiro de 64 bits com sinal complementado a dois + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L é usado para indicar que o valor da variável é do tipo Long; + // sem o L, tudo é tratado como inteiro por padrão. + + // Nota: Java não tem tipos sem sinal + + // Float - Ponto Flutuante 32-bits, de precisão simples no padrão IEEE 754 + float fooFloat = 234.5f; + // f é usado para indicar que o valor da variável é do tipo float; + // caso contrário, ela é tratada como double. + + // Double - Ponto Flutuante 64-bits, de precisão dupla no padrão IEEE 754 + double fooDouble = 123.4; + + // Boolean - true & false + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - Um caractere Unicode de 16 bits + char fooChar = 'A'; + + // Usa-se o final para fazer com que a variável seja imutável. + final int HORAS_QUE_TRABALHEI_POR_SEMANA = 9001; + + // Strings + String fooString = "Aqui está minha String!"; + + // \n é um caractere de escape que inicia uma nova linha + String barString = "Imprimir em uma nova linha?\nSem problemas!"; + // \t é um caractere de escape que adiciona um caractere de tabulação + String bazString = "Você quer adicionar tabulação?\tSem problemas!"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // Arrays + //O tamanho do array precisa ser determinado na sua declaração + //O formato para declarar um array é: + //<tipo de dado> [] <nome da variável> = new <tipo de dado>[<tamanho do array>]; + int [] intArray = new int[10]; + String [] stringArray = new String[1]; + boolean [] booleanArray = new boolean[100]; + + // Outra maneira de declarar e inicializar um array + int [] y = {9000, 1000, 1337}; + + // Indexando um array - Acessando um elemento + System.out.println("intArray no índice 0: " + intArray[0]); + + // O primeiro termo de um array é o 0 e eles são mutáveis. + intArray[1] = 1; + System.out.println("intArray no índice 1: " + intArray[1]); // => 1 + + // Outras estruturas que devem ser vistas + // ArrayLists - São parecidos com os arrays, porém oferecem mais funcionalidades + // e o tamanho é mutável. + // LinkedLists + // Maps + // HashMaps + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + System.out.println("\n->Operadores"); + + int i1 = 1, i2 = 2; // Forma abreviada de escrever múltiplas declarações. + + // Aritmética é feita da forma convencional + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 arredondado para baixo) + + // Módulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Operadores de comparação + System.out.println("3 == 2? " + (3 == 2)); // => false + System.out.println("3 != 2? " + (3 != 2)); // => true + System.out.println("3 > 2? " + (3 > 2)); // => true + System.out.println("3 < 2? " + (3 < 2)); // => false + System.out.println("2 <= 2? " + (2 <= 2)); // => true + System.out.println("2 >= 2? " + (2 >= 2)); // => true + + // Operadores bit-a-bit! + /* + ~ Complemento de um + << Deslocamento a esquerda com sinal + >> Deslocamento a direita com sinal + >>> Deslocamento a direita sem sinal + & E bit-a-bit + | OU bit-a-bit + ^ OU exclusivo bit-a-bit + */ + + // Incrementações + int i = 0; + System.out.println("\n->Inc/Dec-rementação"); + System.out.println(i++); //i = 1. Pós-Incrementação + System.out.println(++i); //i = 2. Pre-Incrementação + System.out.println(i--); //i = 1. Pós-Decrementação + System.out.println(--i); //i = 0. Pre-Decrementação + + /////////////////////////////////////// + // Estruturas de Controle + /////////////////////////////////////// + System.out.println("\n->Estruturas de Controle"); + + // Os comandos If são parecidos com o da linguagem C + int j = 10; + if (j == 10){ + System.out.println("Eu serei impresso"); + } else if (j > 10) { + System.out.println("Eu não"); + } else { + System.out.println("Eu também não"); + } + + // O Loop While + int fooWhile = 0; + while(fooWhile < 100) + { + //System.out.println(fooWhile); + //Incrementando o contador + //Iteração feita 99 vezes, fooWhile 0->99 + fooWhile++; + } + System.out.println("Valor do fooWhile: " + fooWhile); + + // O Loop Do While + int fooDoWhile = 0; + do + { + //System.out.println(fooDoWhile); + //Incrementando o contador + //Iteração feita 99 vezes, fooDoWhile 0->99 + fooDoWhile++; + }while(fooDoWhile < 100); + System.out.println("Valor do fooDoWhile: " + fooDoWhile); + + // O Loop For + int fooFor; + //estrutura do loop for => for(<operação_de_início>; <condição>; <passo>) + for(fooFor=0; fooFor<10; fooFor++){ + //System.out.println(fooFor); + //Iteração feita 10 vezes, fooFor 0->9 + } + System.out.println("Valor do fooFor: " + fooFor); + + // O Loop For Each + // Itera automaticamente por um array ou lista de objetos. + int[] fooList = {1,2,3,4,5,6,7,8,9}; + //estrutura do loop for each => for(<objeto> : <array_de_objeto>) + //lê-se: para cada objeto no array + //nota: o tipo do objeto deve ser o mesmo do array. + + for( int bar : fooList ){ + //System.out.println(bar); + //Itera 9 vezes e imprime 1-9 em novas linhas + } + + // Switch + // Um switch funciona com os tipos de dados: byte, short, char e int + // Ele também funciona com tipos enumerados (vistos em tipos Enum) + // como também a classe String e algumas outras classes especiais + // tipos primitivos: Character, Byte, Short e Integer + int mes = 3; + String mesString; + switch (mes){ + case 1: + mesString = "Janeiro"; + break; + case 2: + mesString = "Fevereiro"; + break; + case 3: + mesString = "Março"; + break; + default: + mesString = "Algum outro mês"; + break; + } + System.out.println("Resultado do Switch: " + mesString); + + // Condição de forma abreviada. + // Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas. + // Lê-se "Se (declaração) é verdadeira, use <primeiro valor> + // caso contrário, use <segundo valor>". + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); //Imprime A, pois a condição é verdadeira. + + + /////////////////////////////////////// + // Convertendo tipos de dados e Casting + /////////////////////////////////////// + + //Conversão de Dados + + //Convertendo String para Inteiro. + Integer.parseInt("123");//retorna uma versão inteira de "123". + + //Convertendo Inteiro para String + Integer.toString(123);//retorna uma versão String de 123. + + // Para outras conversões confira as seguintes classes + // Double + // Long + // String + + // Casting + // Você pode também converter objetos java, há vários detalhes e + // lida com alguns conceitos intermediários + // Dê uma olhada no link: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classes e Métodos + /////////////////////////////////////// + + System.out.println("\n->Classes e Métodos"); + + // (segue a definição da classe Bicicleta) + + // Use o new para instanciar uma classe + Bicicleta caloi = new Bicicleta(); // Objeto caloi criado. + + // Chame os métodos do objeto + caloi.aumentarVelocidade(3); // Você deve sempre usar métodos para modificar variáveis + caloi.setRitmo(100); + + // toString é uma convenção para mostrar o valor deste objeto. + System.out.println("informações de caloi: " + caloi.toString()); + + } // Fim do método main +} // Fim da classe LearnJava + + +// Você pode incluir outras classes que não são públicas num arquivo .java + + +// Sintaxe de declaração de Classe. +// <public/private/protected> class <nome da classe>{ +// // atributos, construtores e todos os métodos. +// // funções são chamadas de métodos em Java. +// } + +class Bicicleta { + + // Atributos/Variáveis da classe Bicicleta. + public int ritmo; // Public: Pode ser acessada em qualquer lugar. + private int velocidade; // Private: Apenas acessível a classe. + protected int catraca; // Protected: Acessível a classe e suas subclasses. + String nome; // default: Apenas acessível ao pacote. + + // Construtores são uma forma de criação de classes + // Este é o construtor padrão. + public Bicicleta() { + catraca = 1; + ritmo = 50; + velocidade = 5; + nome = "Bontrager"; + } + + // Este é um construtor específico (ele contém argumentos). + public Bicicleta (int ritmoInicial, int velocidadeInicial, int catracaInicial, String nome) { + this.catraca = catracaInicial; + this.ritmo = ritmoInicial; + this.velocidade = velocidadeInicial; + this.nome = nome; + } + + // Sintaxe de um método: + // <public/private/protected> <tipo de retorno> <nome do método>(<args>) // + + // Classes em Java costumam implementar métodos getters e setters para seus campos. + + // Sintaxe de declaração de métodos + // <escopo> <tipo de retorno> <nome do método>(<args>) // + public int getRitmo() { + return ritmo; + } + + // Métodos do tipo void não requerem declaração de retorno. + public void setRitmo(int novoValor) { + ritmo = novoValor; + } + + public void setEquipamento(int novoValor) { + catraca = novoValor; + } + + public void aumentarVelocidade(int incremento) { + velocidade += incremento; + } + + public void diminuirVelocidade(int decremento) { + velocidade -= decremento; + } + + public void setNome(String novoNome) { + nome = novoNome; + } + + public String getNome() { + return nome; // retorna um dado do tipo String. + } + + //Método para mostrar os valores dos atributos deste objeto. + @Override + public String toString() { + return "catraca: " + catraca + + " ritmo: " + ritmo + + " velocidade: " + velocidade + + " nome: " + nome; + } +} // fim classe Bicicleta + +// Velocipede é uma subclasse de bicicleta. +class Velocipede extends Bicicleta { + // (Velocípedes são bicicletas com rodas dianteiras grandes + // Elas não possuem catraca.) + + public Velocipede(int ritmoInicial, int velocidadeInicial){ + // Chame o construtor do pai (construtor de Bicicleta) com o comando super. + super(ritmoInicial, velocidadeInicial, 0, "PennyFarthing"); + } + + // Você pode marcar um método que você está substituindo com uma @annotation + // Para aprender mais sobre o que são as annotations e sua finalidade + // dê uma olhada em: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setEquipamento(int catraca) { + catraca = 0; + } + +} + +``` + +## Leitura Recomendada + +Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, use o Google e encontre exemplos específicos. + +Outros tópicos para pesquisar: + +* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceções](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Tipos Genéricos](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Conversões de código Java](http://www.oracle.com/technetwork/java/codeconv-138413.html) + +Livros: + +* [Use a cabeça, Java] (http://www.headfirstlabs.com/books/hfjava/) 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/json-pt.html.markdown b/pt-br/json-pt.html.markdown new file mode 100644 index 00000000..fc63b126 --- /dev/null +++ b/pt-br/json-pt.html.markdown @@ -0,0 +1,62 @@ +--- +language: json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +filename: learnjson-pt.json +--- + +Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o +"Learn X in Y minutes" mais simples existente. + +JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores +aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto, +tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si. + + +```json +{ + "chave": "valor", + + "chaves": "deve ser sempre entre aspas (junto ou separado)", + "números": 0, + "strings": "Olá, mundo. Todo o padrão UNICODE é permitido, junto com \"escapando\".", + "possui booleano?": true, + "nada": null, + + "número grande": 1.2e+100, + + "objetos": { + "comentário": "A maior parte da sua estrutura virá de objetos.", + + "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5], + + "outro objeto": { + "ccomentário": "Estas coisas podem ser aninhadas, muito úteis." + } + }, + + "tolice": [ + { + "fonte de potássio": ["bananas"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "estilo alternativo": { + "comentário": "verificar isso!" + , "posição da vírgula": "não importa - enquanto é antes do valor, então é válido" + , "outro comentário": "que bom" + }, + + "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.". +} +``` diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown new file mode 100644 index 00000000..4030ce3c --- /dev/null +++ b/pt-br/markdown-pt.html.markdown @@ -0,0 +1,251 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +filename: learnmarkdown-pt.md +--- + +Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e +escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também). + +Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e +puxar o projeto (pull request) + +```markdown +<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é +um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML +em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador +de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você +não pode usar sintaxe remarcação dentro desse conteúdo do elemento.--> + +<!--Markdown também varia de implementação de um analisador para uma próxima. +Este guia vai tentar esclarecer quando as características são universais, ou quando eles são +específico para um determinado parser --> + +<!-- Cabeçalhos --> +<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto +que deseja estar nesse elemento por um número de hashes (#) --> +# Isto é um cabeçalho <h1> +## Isto é um cabeçalho <h2> +### Isto é um cabeçalho <h3> +#### Isto é um cabeçalho <h4> +##### Isto é um cabeçalho <h5> +###### Isto é um cabeçalho <h6> + +<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 --> +Isto é um cabeçalho h1 +====================== + +Isto é um cabeçalho h2 +---------------------- + +<!-- Estilos de texto simples --> +<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando --> + +*Este texto está em itálico* +_E este também está._ + +**Este texto está em negrito** +__E este também está._ + +***Este texto está em negrito e itálico.*** +**_E este também está_** +*--Danouse! Este também__* + +<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown +Github, nós também temos: --> + +~~Este texto é processado com tachado.~~ + +<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por +uma ou múltiplas linhas em branco. --> + +Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal? + +Agora, eu estou no parágrado 2. +... Ainda continuo no parágrafo 2! :) + +Eu estou no parágrafo três. + +<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo +com dois ou mais espaços e, em seguida, começar um novo parágrafo --> + +Termino com dois espaços (destacar-me para vê-los). + +Há um <br /> acima de mim! + +<!-- Bloco de citações são fáceis e feito com o caractere >. --> + +> Este é um bloco de citação. Você pode +> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode +> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença, +> desde que eles começam com um `>`. + +> Você também pode usar mais de um nível +>> De recuo? +> Como pura é isso? + +<!-- Listas --> +<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens --> + +* Item +* Item +* Outro item + +ou + ++ Item ++ Item ++ Outro item + +ou + +- Item +- Item +- Um último item + +<!-- Listas ordenadas são feitas com um número seguido por um ponto --> + +1. Item um +2. Item dois +3. Tem três + +<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda +tornar os números em ordem, mas isso pode não ser uma boa idéia --> + +1. Item um +1. Item dois +1. Item três +<!-- (Isto é processado da mesma forma que o exemplo acima) --> + +<!-- Você também pode usar subtítulos --> + +1. Item um +2. Item dois +3. Item três + * Sub-item + * Sub-item +4. Item quatro + +<!-- blocos de código --> +<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo +uma linha com quatro espaços ou uma guia --> + + Isto é código + É assim, sacou? + +<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo +dentro do seu código --> + + my_array.each do |item| + puts item + end + +<!-- Código embutido pode ser criada usando o caractere de crase ` --> + +John não sabia nem o que o função 'goto()' fazia! + +<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código --> + +\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ``` +ruby! --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` --> + +<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe +destacando do idioma que você especificar após a ``` --> + +<!-- Regra Horizontal (<hr />) --> +<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens, +com ou sem espaços. --> + +*** +--- +- - - +**************** + +<!-- Links --> +<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar +o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () --> + +[Click aqui!](http://test.com/) + +<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses --> + +[Click aqui!](http://test.com/ "Link para Test.com") + +<!-- Caminhos relativos funcionam também. --> + +[Ir para música](/música/). + +<!-- Markdown também suporta ligações de estilo de referência --> + +[Clique neste link] [link1] para mais informações sobre isso! +[Além disso, verifique este link] [foobar] se você quiser. + +[link1]: http://test.com/ "Legal!" +[foobar]: http://foobar.biz/ "OK!" + +<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido +inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência +pode ser qualquer um, desde que eles são únicos. --> + +<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id --> + +[Este] [] é um link. + +[este]: http://thisisalink.com/ + +<!-- Mas não são usados normalmente--> + +<!-- Imagens --> +<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! --> + + + +<!-- E estilo de referência funciona como esperado --> + +![Este é o pairar-texto.][Myimage] + +[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" + +<!-- Miscelânea --> +<!-- Auto-links --> + +<http://testwebsite.com/> é equivalente a +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Auto-links para e-mails --> + +<foo@bar.com> + +<!-- Escapando caracteres --> + +Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja +em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*. + +<!-- Tabelas --> +<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente +complicadas, mas se você realmente quer: --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| esquerda-alin| Centrado | direita-alinh | +| blah | blah | blah | + +<!-- Ou, para os mesmos resultados --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ugh isso é tão feio | faça isto | parar + +<!-- O fim! --> + +``` +Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax) +e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown new file mode 100644 index 00000000..cc07a2ec --- /dev/null +++ b/pt-br/perl-pt.html.markdown @@ -0,0 +1,166 @@ +--- +name: perl +category: language +language: perl +filename: learnperl-pt.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +Perl 5 é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento. + +Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala. + +```perl +# Comentários de uma linha começam com um sinal de número. + +#### Tipos de variáveis em Perl + +# Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo. +# Um nome de variável válido começa com uma letra ou sublinhado, +# seguido por qualquer número de letras, números ou sublinhados. + +### Perl has three main variable types: $scalar, @array, e %hash. + +## Scalars +# Um scalar representa um valor único: +my $animal = "camelo"; +my $resposta = 42; + +# Valores scalar podem ser strings, inteiros ou números ponto-flutuantes e +# Perl vai automaticamente converter entre eles quando for preciso. + +## Arrays +# Um array representa uma lista de valores: +my @animais = ("camelo", "vaca", "boi"); +my @números = (23, 42, 69); +my @misturado = ("camelo", 42, 1.23); + +## Hashes +# Um hash representa um conjunto de pares chave/valor: + +my %fruta_cor = ("maçã", "vermelho", "banana", "amarelo"); + +# Você pode usar o espaço em branco e o operador "=>" para colocá-los de +# maneira mais agradável: + +my %fruta_cor = ( + maçã => "vermelho", + banana => "amarelo", +); + +# Scalars, arrays and hashes são documentados mais profundamentes em perldata. +# (perldoc perldata). + +# Mais tipos de dados complexos podem ser construídas utilizando referências, +# o que permite que você crie listas e hashes dentro de listas e hashes. + +#### Condicionais e construtores de iteração + +# Perl possui a maioria das construções condicionais e de iteração habituais. + +if ($var) { + ... +} elsif ($var eq 'bar') { + ... +} else { + ... +} + +unless (condição) { + ... +} +# Isto é fornecido como uma versão mais legível de "if (!condition)" + +# A forma Perlish pós-condição +print "Yow!" if $zippy; +print "Nós não temos nenhuma banana" unless $bananas; + +# while +while (condição) { + ... +} + +# for +for (my $i = 0; $i < $max; $i++) { + print "valor é $i"; +} + +for (my $i = 0; $i < @elements; $i++) { + print "Elemento atual é " . $elements[$i]; +} + +for my $element (@elements) { + print $element; +} + +# implícito + +for (@elements) { + print; +} + +#### Expressões regulares + +# O suporte a expressões regulares do Perl é ao mesmo tempo amplo e profundo, +# e é objeto de longa documentação em perlrequick, perlretut, e em outros +# lugares. No entanto, em suma: + +# Casamento simples +if (/foo/) { ... } # verdade se $_ contém "foo" +if ($a =~ /foo/) { ... } # verdade se $a contém "foo" + +# Substituição simples + +$a =~ s/foo/bar/; # substitui foo com bar em $a +$a =~ s/foo/bar/g; # substitui TODAS AS INSTÂNCIAS de foo com bar em $a + +#### Arquivos e I/O + +# Você pode abrir um arquivo para entrada ou saída usando a função "open()". + +open(my $in, "<", "input.txt") ou desistir "Não pode abrir input.txt: $!"; +open(my $out, ">", "output.txt") ou desistir "Não pode abrir output.txt: $!"; +open(my $log, ">>", "my.log") ou desistir "Não pode abrir my.log: $!"; + +# Você pode ler de um arquivo aberto usando o operador "<>". No contexto +# scalar, ele lê uma única linha do arquivo, e em contexto de lista lê o +# arquivo inteiro, atribuindo cada linha a um elemento da lista: + +my $linha = <$in>; +my @linhas = <$in>; + +#### Escrevendo subrotinas + +# Escrever subrotinas é fácil: + +sub logger { + my $mensagem = shift; + + open my $arquivo, ">>", "my.log" or die "Não poderia abrir my.log: $!"; + + print $arquivo $ensagem; +} + +# Agora nós podemos usar a subrotina como qualquer outra função construída: + +logger("Nós temos uma subrotina de log!"); +``` + +#### Usando módulos Perl + +Módulos Perl provê uma lista de recursos para lhe ajudar a evitar redesenhar +a roda, e tudo isso pode ser baixado do CPAN (http://www.cpan.org/). Um número +de módulos populares podem ser incluídos com a própria distribuição do Perl. + +perlfaq contém questões e respostas relacionadas a muitas tarefas comuns, e frequentemente provê sugestões para um bom números de módulos CPAN. + +#### Leitura Adicional + + - [perl-tutorial](http://perl-tutorial.org/) + - [Learn at www.perl.com](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - and perl built-in : `perldoc perlintro` diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown new file mode 100644 index 00000000..0e710742 --- /dev/null +++ b/pt-br/php-pt.html.markdown @@ -0,0 +1,700 @@ +--- +language: PHP +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +translators: + - ["Abdala Cerqueira", "http://abda.la"] + - ["Raquel Diniz", "http://twitter.com/raquelrdiniz"] +lang: pt-br +filename: learnphp-pt.php +--- + +Este documento descreve PHP 5+. + +```php +<?php // O código PHP deve estar incluso na tag <?php + +// Se o arquivo PHP só contém código PHP, a melhor prática +// é omitir a tag de fechamento PHP. + +// Duas barras iniciam o comentário de uma linha. + +# O hash (aka pound symbol) também inicia, mas // é mais comum + +/* + O texto envolto por barra-asterisco e asterisco-barra + faz um comentário de múltiplas linhas +*/ + +// Utilize "echo" ou "print" para imprimir a saída +print('Olá '); // Imprime "Olá " sem quebra de linha + +// () são opcionais para print e echo +echo "Mundo\n"; // Imprime "Mundo" com quebra de linha +// (Todas as declarações devem terminar com um ponto e vírgula) + +// Qualquer coisa fora da tag <?php é impresso automaticamente +?> +Olá mundo novamente! +<?php + + +/************************************ + * Tipos e variáveis + */ + +// Variáveis começam com o símbolo $. +// Um nome de variável válido se inicia com uma letra ou sublinhado, +// seguido por qualquer quantidade de letras, números ou sublinhados. + +// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive) +$boolean = true; // ou TRUE ou True +$boolean = false; // ou FALSE ou False + +// Inteiros +$int1 = 12; // => 12 +$int2 = -12; // => -12 +$int3 = 012; // => 10 (um 0 denota um número octal) +$int4 = 0x0F; // => 15 (um 0x denota um literal hex) + +// Flutuantes - Floats (aka doubles) +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Excluir variável +unset($int1) + +// Aritmética +$soma = 1 + 1; // 2 +$diferenca = 2 - 1; // 1 +$produto = 2 * 2; // 4 +$quociente = 2 / 1; // 2 + +// Taquigrafia aritmética +$numero = 0; +$numero += 1; // Incrementa $number em 1 +echo $numero++; // Imprime 1 (incrementa após a avaliação) +echo ++$numero; // Imprime 3 (incrementa antes da avaliação) +$numero /= $float; // Divide e atribui o quociente de $numero + +// Strings podem ser colocadas entre aspas simples +$sgl_quotes = '$String'; // => '$String' + +// Evite o uso de aspas duplas, exceto para incorporar outras variáveis +$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.' + +// Os caracteres especiais só são escapados entre aspas duplas +$escapado = "Este contém um \t caractere tab."; +$naoescapado = 'Este contém somente a barra e o t: \t'; + +// Coloque uma variável entre chaves se necessário +$dinheiro = "Eu tenho $${numero} no banco."; + +// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise +$nowdoc = <<<'FIM' +múltiplas linhas +string +FIM; + +// Heredocs farão a análise +$heredoc = <<<FIM +múltiplas linhas +$sgl_quotes +FIM; + +// Concatenação de string é feita com . +echo 'Esta string ' . 'é concatenada'; + + +/******************************** + * Constantes + */ + +// Uma constante é definida usando define() +// e nunca pode ser mudada durante a execução! + +// Um nome de constante válida começa com uma letra ou sublinhado, +// seguido por qualquer quantidade de letras, números ou sublinhados. +define("FOO", "alguma coisa"); + +// Acesso a uma constante é possível usando diretamente o nome escolhido +echo 'Isto sairá '.FOO; + + +/******************************** + * Arrays + */ + +// Todos os arrays em PHP são arrays associativos (hashmaps), + +// Funciona com todas as versões do PHP +$associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3); + +// PHP 5.4 introduziu uma nova sintaxe +$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3]; + +echo $associativo['Um']; // imprime 1 + +// Uma lista de literais atribui chaves inteiras implicitamente +$array = ['Um', 'Dois', 'Tres']; +echo $array[0]; // => "Um" + +// Adiciona um elemento no final do array +$array[] = 'Quatro'; + +// Remove um elemento do array +unset($array[3]); + +/******************************** + * Saída + */ + +echo('Olá Mundo!'); +// Imprime Olá Mundo! para stdout. +// Stdout é uma página web se executado em um navegador. + +print('Olá Mundo!'); // O mesmo que o echo + +// echo é atualmente um construtor de linguagem, então você pode +// remover os parênteses. +echo 'Olá Mundo!'; +print 'Olá Mundo!'; // O print também é + +$paragrafo = 'parágrafo'; + +echo 100; // Imprime valores escalares diretamente +echo $paragrafo; // ou variáveis + +// Se a abertura de tags curtas está configurada, ou sua versão do PHP é +// 5.4.0 ou maior, você pode usar a sintaxe de echo curto +?> +<p><?= $paragrafo ?></p> +<?php + +$x = 1; +$y = 2; +$x = $y; // $x agora contém o mesmo valor de $y +$z = &$y; +// $z agora contém uma referência para $y. Mudando o valor de +// $z irá mudar o valor de $y também, e vice-versa. +// $x irá permanecer inalterado com o valor original de $y + +echo $x; // => 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 + +// Despeja tipos e valores de variável para o stdout +var_dump($z); // imprime int(0) + +// Imprime variáveis para stdout em formato legível para humanos +print_r($array); // imprime: Array ( [0] => Um [1] => Dois [2] => Tres ) + +/******************************** + * Lógica + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; + +// assert lança um aviso se o seu argumento não é verdadeiro + +// Estas comparações serão sempre verdadeiras, mesmo que os tipos +// não sejam os mesmos. +assert($a == $b); // igualdade +assert($c != $a); // desigualdade +assert($c <> $a); // alternativa para desigualdade +assert($a < $c); +assert($c > $b); +assert($a <= $b); +assert($c >= $d); + +// A seguir, só serão verdadeiras se os valores correspondem e são do mesmo tipo. +assert($c === $d); +assert($a !== $d); +assert(1 == '1'); +assert(1 !== '1'); + +// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização. + +$inteiro = 1; +echo $inteiro + $inteiro; // => 2 + +$string = '1'; +echo $string + $string; // => 2 (strings são coagidas para inteiros) + +$string = 'one'; +echo $string + $string; // => 0 +// Imprime 0 porque o operador + não pode fundir a string 'um' para um número + +// Tipo de fundição pode ser utilizado para tratar uma variável +// como um outro tipo + +$booleano = (boolean) 1; // => true + +$zero = 0; +$booleano = (boolean) $zero; // => false + +// Há também funções dedicadas para fundir a maioria dos tipos +$inteiro = 5; +$string = strval($inteiro); + +$var = null; // valor Null + + +/******************************** + * Estruturas de controle + */ + +if (true) { + print 'Eu fico impresso'; +} + +if (false) { + print 'Eu não\'t'; +} else { + print 'Eu fico impresso'; +} + +if (false) { + print 'Não fica impresso'; +} elseif(true) { + print 'Fica'; +} + +// operadores ternários +print (false ? 'Não fica impresso' : 'Fica'); + +$x = 0; +if ($x === '0') { + print 'Não imprime'; +} elseif($x == '1') { + print 'Não imprime'; +} else { + print 'Imprime'; +} + + + +// Esta sintaxe alternativa é útil para modelos (templates) +?> + +<?php if ($x): ?> +Isto é exibido se o teste for verdadeiro. +<?php else: ?> +Isto é apresentado caso contrário. +<?php endif; ?> + +<?php + +// Use switch para salvar alguma lógica. +switch ($x) { + case '0': + print 'Switch faz coerção de tipo'; + break; // Você deve incluir uma pausa, ou você vai cair + // no caso 'dois' e 'tres' + case 'dois': + case 'tres': + // Faz alguma coisa, se a variável é 'dois' ou 'tres' + break; + default: + // Faz algo por padrão +} + +// While, do...while e for são repetições provavelmente familiares +$i = 0; +while ($i < 5) { + echo $i++; +}; // Imprime "01234" + +echo "\n"; + +$i = 0; +do { + echo $i++; +} while ($i < 5); // Imprime "01234" + +echo "\n"; + +for ($x = 0; $x < 10; $x++) { + echo $x; +} // Imprime "0123456789" + +echo "\n"; + +$rodas = ['bicicleta' => 2, 'carro' => 4]; + +// Repetições foreach podem iterar sobre arrays +foreach ($rodas as $contador_rodas) { + echo $contador_rodas; +} // Imprime "24" + +echo "\n"; + +// Você pode iterar sobre as chaves, bem como os valores +foreach ($rodas as $veiculo => $contador_rodas) { + echo "O $veiculo tem $contador_rodas rodas"; +} + +echo "\n"; + +$i = 0; +while ($i < 5) { + if ($i === 3) { + break; // Sai da repetição + } + echo $i++; +} // Imprime "012" + +for ($i = 0; $i < 5; $i++) { + if ($i === 3) { + continue; // Ignora esta iteração da repetição + } + echo $i; +} // Imprime "0124" + + +/******************************** + * Functions + */ + +// Define a função com "function": +function minha_funcao () { + return 'Olá'; +} + +echo minha_funcao(); // => "Olá" + +// Um nome de função válido começa com uma letra ou sublinhado, +// seguido por qualquer quantidade de letras, números ou sublinhados. + +function adicionar($x, $y = 1) { // $y é opcional e o valor padrão é 1 + $resultado = $x + $y; + return $resultado; +} + +echo adicionar(4); // => 5 +echo adicionar(4, 2); // => 6 + +// $resultado não é acessível fora da função +// print $resultado; // Dá uma aviso. + +// Desde o PHP 5.3 você pode declarar funções anônimas +$inc = function ($x) { + return $x + 1; +}; + +echo $inc(2); // => 3 + +function foo ($x, $y, $z) { + echo "$x - $y - $z"; +} + +// Funções podem retornar funções +function bar ($x, $y) { + // Utilize 'use' para trazer variáveis de fora + return function ($z) use ($x, $y) { + foo($x, $y, $z); + }; +} + +$bar = bar('A', 'B'); +$bar('C'); // Imprime "A - B - C" + +// Você pode chamar funções nomeadas usando strings +$nome_funcao = 'add'; +echo $nome_funcao(1, 2); // => 3 +// Útil para dinamicamente determinar qual função será executada. +// Ou utilize call_user_func(callable $callback [, $parameter [, ... ]]); + +/******************************** + * Includes (Incluir) + */ + +<?php +// PHP dentro de arquivos incluídos também deve começar com uma tag +// de abertura do PHP. + +include 'meu-arquivo.php'; +// O código meu-arquivo.php já está disponível no escopo atual. +// Se o arquivo não pode ser incluído (por exemplo, arquivo não encontrado), +//um aviso é emitido. + +include_once 'meu-arquivo.php'; +// Se o código no meu-arquivo.php foi incluído em outro lugar, ele não vai +// ser incluído novamente. Isso evita vários erros de declaração de classe + +require 'meu-arquivo.php'; +require_once 'meu-arquivo.php'; +// Faz o mesmo que o include(), exceto que o require() irá causar um erro fatal +// se o arquivo não puder ser incluído + +// Conteúdo de meu-include.php: +<?php + +return 'Qualquer coisa que você quiser.'; +// Fim do arquivo + +// Includes e requires também podem retornar um valor. +$valor = include 'meu-include.php'; + +// Arquivos são incluídos com base no caminho determinado ou, +// se este não for passado, com base na diretiva de configuração include_path. +// Se o arquivo não é encontrado no include_path, o include vai finalmente +// verificar no próprio diretório do script chamado e no diretório +// de trabalho atual antes de falhar. +/* */ + +/******************************** + * Classes + */ + +// As classes são definidas com a palavra-chave class + +class MinhaClasse +{ + const MINHA_CONST = 'valor'; // Uma constante + + static $valorEstatico = 'estatico'; + + // Variáveis estáticas e sua visibilidade + public static $valorEstaticoPublico = 'estaticoPublico'; + // Acessível somente dentro da classe + private static $valorEstaticoPrivado = 'estaticoPrivado'; + // Acessível a partir da classe e subclasses + protected static $valorEstaticoProtegido = 'estaticoProtegido'; + + // Propriedades devem declarar a sua visibilidade + public $propriedade = 'publica'; + public $propInstancia; + protected $prot = 'protegida'; // Acessível a partir da classe e subclasses + private $priv = 'privada'; // Acessível somente dentro da classe + + // Criar um construtor com o __construct + public function __construct($propInstancia) { + // Acesse variável de instância utilizando $this + $this->propInstancia = $propInstancia; + } + + // Métodos são declarados como funções dentro de uma classe + public function meuMetodo() + { + print 'MinhaClasse'; + } + + //palavra-chave final faz uma função não poder ser sobrescrita + final function voceNaoPodeMeSobrescrever() + { + } + +/* + * Declarando propriedades ou métodos de classe como estáticos faz deles + * acessíveis sem precisar instanciar a classe. A propriedade declarada + * como estática não pode ser acessada com um objeto + * instanciado da classe (embora métodos estáticos possam). +*/ + + public static function meuMetodoEstatico() + { + print 'Eu sou estatico'; + } +} + +echo MinhaClasse::MINHA_CONST; // Imprime 'valor'; +echo MinhaClasse::$valorEstatico; // Imprime 'estatico'; +MinhaClasse::meuMetodoEstatico(); // Imprime 'Eu sou estatico'; + +// Instantiate classes using new +$minha_classe = new MinhaClasse('Uma propriedade de instância'); +// Os parênteses são opcionais, se não passar algum argumento. + +// Acesse membros da classe utilizando -> +echo $minha_classe->propriedade; // => "publica" +echo $minha_classe->instanceProp; // => "Uma propriedade de instância" +$minha_classe->meuMetodo(); // => "MinhaClasse" + + +// Estender classes usando "extends" +class MinhaOutraClasse extends MinhaClasse +{ + function imprimePropriedadeProtegida() + { + echo $this->prot; + } + + // Sobrescrever um método + function meuMetodo() + { + parent::meuMetodo(); + print ' > MinhaOutraClasse'; + } +} + +$minha_outra_classe = new MinhaOutraClasse('Propriedade de instância'); +$minha_outra_classe->imprimePropriedadeProtegida(); // => Prints "protegida" +$minha_outra_classe->myMethod(); // Prints "MinhaClasse > MinhaOutraClasse" + +final class VoceNaoPodeMeEstender +{ +} + +// Você pode usar "métodos mágicos" para criar getters e setters +class MinhaClasseMapa +{ + private $propriedade; + + public function __get($chave) + { + return $this->$chave; + } + + public function __set($chave, $valor) + { + $this->$chave = $valor; + } +} + +$x = new MinhaClasseMapa(); +echo $x->propriedade; // Irá usar o método __get() +$x->propriedade = 'Algo'; // Irá usar o método __set() + +// Classes podem ser abstratas (usando a palavra-chave abstract) ou +// implementar interfaces (usando a palavra-chave implements). +// Uma interface é declarada com a palavra-chave interface. + +interface InterfaceUm +{ + public function fazAlgo(); +} + +interface InterfaceDois +{ + public function fazOutraCoisa(); +} + +// interfaces podem ser estendidas +interface InterfaceTres extends InterfaceDois +{ + public function fazOutroContrato(); +} + +abstract class MinhaClasseAbstrata implements InterfaceUm +{ + public $x = 'fazAlgo'; +} + +class MinhaClasseConcreta extends MinhaClasseAbstrata implements InterfaceDois +{ + public function fazAlgo() + { + echo $x; + } + + public function fazOutraCoisa() + { + echo 'fazOutraCoisa'; + } +} + + +// Classes podem implementar mais de uma interface +class UmaOutraClasse implements InterfaceUm, InterfaceDois +{ + public function fazAlgo() + { + echo 'fazAlgo'; + } + + public function fazOutraCoisa() + { + echo 'fazOutraCoisa'; + } +} + + +/******************************** + * Traits (Traços) + */ + +// Traits estão disponíveis a partir de PHP 5.4.0 e +// são declarados usando "trait" + +trait MeuTraco +{ + public function meuMetodoDeTraco() + { + print 'Eu tenho MeuTraco'; + } +} + +class MinhaClasseTracada +{ + use MeuTraco; +} + +$cls = new MinhaClasseTracada(); +$cls->meuMetodoDeTraco(); // Imprime "Eu tenho MeuTraco" + + +/******************************** + * Namespaces (Espaço nominal) + */ + +// Esta seção é separada porque a declaração de espaços nominais +// deve ser a primeira instrução em um arquivo. Vamos fingir, aqui não é o caso + +<?php + +// Por padrão, as classes existem no espaço nominal global e podem +// ser explicitamente chamadas com uma barra invertida. + +$cls = new \MinhaClasse(); + + + +// Definir o espaço nominal para o arquivo +namespace Meu\Espaconominal; + +class MinhaClasse +{ +} + +// (de outro arquivo) +$cls = new Meu\Espaconominal\MinhaClasse; + +//Ou de dentro de outro espaço nominal. +namespace Meu\Outro\Espaconominal; + +use My\Espaconominal\MinhaClasse; + +$cls = new MinhaClasse(); + +//Ou você pode usar como apelido de espaço nominal; + +namespace Meu\Outro\Espaconominal; + +use Meu\Espaconominal as OutroEspaconominal; + +$cls = new OutroEspaconominal\MinhaClasse(); + +*/ + +``` + +## Mais informações + +Visite a [documentação oficial do PHP](http://www.php.net/manual/) +para referência e participação da comunidade. + +Se você estiver interessado em melhores práticas atualizadas, visite +[PHP The Right Way](http://www.phptherightway.com/). + +Se você está vindo de uma linguagem com bom gerenciamento de pacotes, confira +[Composer](http://getcomposer.org/). + +Para os padrões comuns, visite o Grupo de Interoperabilidade de Framework PHP +[PSR standards](https://github.com/php-fig/fig-standards). diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown new file mode 100644 index 00000000..5afd46d0 --- /dev/null +++ b/pt-br/python-pt.html.markdown @@ -0,0 +1,509 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Vilson Vieira", "http://automata.cc"] +lang: pt-br +filename: learnpython-pt.py +--- + +Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma +das linguagens de programação mais populares. Eu me apaixonei por Python, por +sua clareza de sintaxe. É basicamente pseudocódigo executável. + +Comentários serão muito apreciados! Você pode me contactar em +[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba] +[serviço de email do google] + +Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a +qualquer Python 2.x. Logo haverá uma versão abordando Python 3! + +```python +# Comentários de uma linha começam com cerquilha (ou sustenido) +""" Strings de várias linhas podem ser escritas + usando três ", e são comumente usadas + como comentários +""" + +#################################################### +## 1. Tipos de dados primitivos e operadores +#################################################### + +# Você usa números normalmente +3 #=> 3 + +# Operadores matemáticos são aqueles que você já está acostumado +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# A divisão é um pouco estranha. A divisão de números inteiros arredonda +# para baixo o resultado, automaticamente +5 / 2 #=> 2 + +# Para concertar a divisão, precisamos aprender sobre números de ponto +# flutuante (conhecidos como 'float'). +2.0 # Isso é um 'float' +11.0 / 4.0 #=> 2.75 ahhh... muito melhor + +# Forçamos a precedência de operadores usando parênteses +(1 + 3) * 2 #=> 8 + +# Valores booleanos (ou 'boolean') são também tipos primitivos +True +False + +# Negamos usando 'not' +not True #=> False +not False #=> True + +# Testamos igualdade usando '==' +1 == 1 #=> True +2 == 1 #=> False + +# E desigualdade com '!=' +1 != 1 #=> False +2 != 1 #=> True + +# Mais comparações +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# As comparações podem ser encadeadas! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Strings são criadas com " ou ' +"Isso é uma string." +'Isso também é uma string.' + +# Strings podem ser somadas (ou melhor, concatenadas)! +"Olá " + "mundo!" #=> "Olá mundo!" + +# Uma string pode ser tratada como uma lista de caracteres +"Esta é uma string"[0] #=> 'E' + +# O caractere % pode ser usado para formatar strings, desta forma: +"%s podem ser %s" % ("strings", "interpoladas") + +# Um jeito novo de formatar strings é usando o método 'format'. +# Esse método é o jeito mais usado +"{0} podem ser {1}".format("strings", "formatadas") +# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar. +"{nome} quer comer {comida}".format(nome="João", comida="lasanha") + +# 'None' é um objeto +None #=> None + +# Não use o operador de igualdade `==` para comparar objetos com 'None' +# Ao invés disso, use `is` +"etc" is None #=> False +None is None #=> True + +# O operador 'is' teste a identidade de um objeto. Isso não é +# muito útil quando estamos lidando com valores primitivos, mas é +# muito útil quando lidamos com objetos. + +# None, 0, e strings/listas vazias são todas interpretadas como 'False'. +# Todos os outros valores são 'True' +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variáveis e Coleções +#################################################### + +# Imprimir na tela é muito fácil +print "Eu sou o Python. Prazer em te conhecer!" + + +# Nós não precisamos declarar variáveis antes de usá-las, basta usar! +alguma_variavel = 5 # A convenção é usar caixa_baixa_com_sobrescritos +alguma_variavel #=> 5 + +# Acessar uma variável que não teve nenhum valor atribuído anteriormente é +# uma exceção. +# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção. +outra_variavel # Gera uma exceção de erro de nome + +# 'if' pode ser usado como uma expressão +"uepa!" if 3 > 2 else 2 #=> "uepa!" + +# Listas armazenam sequências de elementos +lista = [] +# Você pode inicializar uma lista com valores +outra_lista = [4, 5, 6] + +# Adicione elementos no final da lista usando 'append' +lista.append(1) # lista é agora [1] +lista.append(2) # lista é agora [1, 2] +lista.append(4) # lista é agora [1, 2, 4] +lista.append(3) # lista é agora [1, 2, 4, 3] +# Remova elementos do fim da lista usando 'pop' +lista.pop() #=> 3 e lista é agora [1, 2, 4] +# Vamos adicionar o elemento novamente +lista.append(3) # lista agora é [1, 2, 4, 3] novamente. + +# Acesse elementos de uma lista através de seu índices +lista[0] #=> 1 +# Acesse o último elemento com índice negativo! +lista[-1] #=> 3 + +# Tentar acessar um elemento fora dos limites da lista gera uma exceção +# do tipo 'IndexError' +lista[4] # Gera uma exceção 'IndexError' + +# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de +# limites +# (Para quem gosta de matemática, isso é um limite fechado/aberto) +lista[1:3] #=> [2, 4] +# Você pode omitir o fim se quiser os elementos até o final da lista +lista[2:] #=> [4, 3] +# O mesmo para o início +lista[:3] #=> [1, 2, 4] + +# Remova um elemento qualquer de uma lista usando 'del' +del lista[2] # lista agora é [1, 2, 3] + +# Você pode somar listas (obs: as listas originais não são modificadas) +lista + outra_lista #=> [1, 2, 3, 4, 5, 6] + +# Você também pode concatenar usando o método 'extend' (lista será modificada!) +lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6] + +# Para checar se um elemento pertence a uma lista, use 'in' +1 in lista #=> True + +# Saiba quantos elementos uma lista possui com 'len' +len(lista) #=> 6 + + +# Tuplas são iguais a listas, mas são imutáveis +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Isso gera uma exceção do tipo TypeError + +# Você pode fazer nas tuplas todas aquelas coisas fez com a lista +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada +# elemento da tupla/lista a uma variável correspondente +a, b, c = (1, 2, 3) # a agora é 1, b agora é 2, c agora é 3 +# Tuplas são criadas por padrão, mesmo se você não usar parênteses +d, e, f = 4, 5, 6 +# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis! +e, d = d, e # d agora é 5, e agora é 4 + + +# Dicionários armazenam 'mapeamentos' (do tipo chave-valor) +dicionario_vazio = {} +# Aqui criamos um dicionário já contendo valores +dicionario = {"um": 1, "dois": 2, "três": 3} + +# Acesse valores usando [] +dicionario["um"] #=> 1 + +# Retorna uma lista com todas as chaves do dicionário +dicionario.keys() #=> ["três", "dois", "um"] +# Nota: A ordem das chaves não é garantida. +# O resultado no seu interpretador não necessariamente será igual a esse. + +# Retorna uma lista com todos os valores do dicionário +dicionario.values() #=> [3, 2, 1] +# Nota: A mesma nota acima sobre a ordenação é válida aqui. + +# Veja se uma chave qualquer está em um dicionário usando 'in' +"um" in dicionario #=> True +1 in dicionario #=> False + +# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError' +dicionario["quatro"] # Gera uma exceção KeyError + +# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'. +# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir. +dicionario.get("um") #=> 1 +dicionario.get("quatro") #=> None +# O método 'get' suporta um argumento que diz qual valor deverá ser +# retornado se a chave não existir (ao invés de 'None'). +dicionario.get("um", 4) #=> 1 +dicionario.get("quatro", 4) #=> 4 + +# O método 'setdefault' é um jeito seguro de adicionar um novo par +# chave-valor a um dicionário, associando um valor padrão imutável à uma chave +dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5 +dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5 + + +# Conjuntos (ou sets) armazenam ... bem, conjuntos +# Nota: lembre-se que conjuntos não admitem elementos repetidos! +conjunto_vazio = set() +# Podemos inicializar um conjunto com valores +conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição! + +# Desde o Python 2.7, {} pode ser usado para declarar um conjunto +conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Adicione mais ítens a um conjunto com 'add' +conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5} + +# Calcule a intersecção de dois conjuntos com & +outro_conj = {3, 4, 5, 6} +conjunto & outro_conj #=> {3, 4, 5} + +# Calcule a união de dois conjuntos com | +conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6} + +# E a diferença entre dois conjuntos com - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Veja se um elemento existe em um conjunto usando 'in' +2 in conjunto #=> True +10 in conjunto #=> False + + +#################################################### +## 3. Controle +#################################################### + +# Para começar, vamos apenas criar uma variável +alguma_var = 5 + +# Aqui está uma expressão 'if'. Veja como a identação é importante em Python! +# Esses comandos irão imprimir "alguma_var é menor que 10" +if alguma_var > 10: + print "some_var é maior que 10." +elif some_var < 10: # Esse 'elif' é opcional + print "some_var é menor que 10." +else: # Esse 'else' também é opcional + print "some_var é igual a 10." + + +""" +Laços (ou loops) 'for' iteram em listas. +Irá imprimir: + cachorro é um mamífero + gato é um mamífero + rato é um mamífero +""" +for animal in ["cachorro", "gato", "rato"]: + # Você pode usar % para interpolar strings formatadas + print "%s é um mamífero" % animal + +""" +A função `range(um número)` retorna uma lista de números +do zero até o número dado. +Irá imprimir: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +Laços 'while' executam enquanto uma condição dada for verdadeira. +Irá imprimir: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Isso é um atalho para a expressão x = x + 1 + +# Tratamos excessões usando o bloco try/except +# Funciona em Python 2.6 e versões superiores: + +try: + # Use 'raise' para gerar um erro + raise IndexError("Isso é um erro de índice") +except IndexError as e: + pass # Pass é um operador que não faz nada, deixa passar. + # Usualmente você iria tratar a exceção aqui... + + +#################################################### +## 4. Funções +#################################################### + +# Use 'def' para definir novas funções +def soma(x, y): + print "x é %s e y é %s" % (x, y) + return x + y # Retorne valores usando 'return' + +# Chamando funções com parâmetros +soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11 + +# Um outro jeito de chamar funções é especificando explicitamente os valores +# de cada parâmetro com chaves +soma(y=6, x=5) # Argumentos com chaves podem vir em qualquer ordem. + +# Você pode definir funções que recebem um número qualquer de argumentos +# (respeitando a sua ordem) +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Você também pode definir funções que recebem um número qualquer de argumentos +# com chaves +def args_com_chaves(**ch_args): + return ch_args + +# Vamos chamar essa função para ver o que acontece +args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"} + +# Você pode fazer as duas coisas ao mesmo tempo, se desejar +def todos_args(*args, **ch_wargs): + print args + print ch_args +""" +todos_args(1, 2, a=3, b=4) imprime: + (1, 2) + {"a": 3, "b": 4} +""" + +# Quando você chamar funções, pode fazer o oposto do que fizemos até agora! +# Podemos usar * para expandir tuplas de argumentos e ** para expandir +# dicionários de argumentos com chave. +args = (1, 2, 3, 4) +ch_args = {"a": 3, "b": 4} +todos_args(*args) # equivalente a todos_args(1, 2, 3, 4) +todos_args(**ch_args) # equivalente a todos_args(a=3, b=4) +todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4) + +# Em Python, funções são elementos de primeira ordem (são como objetos, +# strings ou números) +def cria_somador(x): + def somador(y): + return x + y + return somador + +soma_10 = cria_somador(10) +soma_10(3) #=> 13 + +# Desta forma, existem também funções anônimas +(lambda x: x > 2)(3) #=> True + +# E existem funções de alta ordem por padrão +map(soma_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] +reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25 + +# Nós podemos usar compreensão de listas para mapear e filtrar também +[soma_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Classes +#################################################### + +# Para criar uma nova classe, devemos herdar de 'object' +class Humano(object): + + # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa + # classe + especie = "H. sapiens" + + # Definimos um inicializador básico + def __init__(self, nome): + # Atribui o valor de argumento dado a um atributo da instância + self.nome = nome + + # Um método de instância. Todos os métodos levam 'self' como primeiro + # argumento + def diga(self, msg): + return "%s: %s" % (self.nome, msg) + + # Um método de classe é compartilhado por todas as instâncias + # Eles são chamados passando o nome da classe como primeiro argumento + @classmethod + def get_especie(cls): + return cls.especie + + # Um método estático é chamado sem uma referência a classe ou instância + @staticmethod + def ronca(): + return "*arrrrrrr*" + + +# Instancie uma classe +i = Humano(nome="Ivone") +print i.diga("oi") # imprime "Ivone: oi" + +j = Human("Joel") +print j.say("olá") #prints out "Joel: olá" + +# Chame nosso método de classe +i.get_especie() #=> "H. sapiens" + +# Modifique um atributo compartilhado +Humano.especie = "H. neanderthalensis" +i.get_especie() #=> "H. neanderthalensis" +j.get_especie() #=> "H. neanderthalensis" + +# Chame o método estático +Humano.ronca() #=> "*arrrrrrr*" + + +#################################################### +## 6. Módulos +#################################################### + +# Você pode importar módulos +import math +print math.sqrt(16) #=> 4 + +# Você pode importar funções específicas de um módulo +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Você também pode importar todas as funções de um módulo +# Atenção: isso não é recomendado! +from math import * + +# Você pode usar apelidos para os módulos, encurtando seus nomes +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Módulos em Python são apenas arquivos Python. Você +# pode escrever o seu próprio módulo e importá-lo. O nome do +# módulo será o mesmo que o nome do arquivo. + +# Você pode descobrir quais funções e atributos +# estão definidos em um módulo qualquer. +import math +dir(math) + + +``` + +## Pronto para mais? + +### Online e gratuito + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Livros impressos + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown new file mode 100644 index 00000000..89a051d4 --- /dev/null +++ b/pt-br/ruby-pt.html.markdown @@ -0,0 +1,387 @@ +--- +language: ruby +lang: pt-br +filename: learnruby-pt.rb +contributors: + - ["Bruno Henrique - Garu", "http://garulab.com"] +translators: + - ["Katyanna Moura", "https://twitter.com/amelie_kn"] +--- + +```ruby +# Isso é um comentário + +=begin +Isso é um comentário multilinha +Ninguém os usa +Você não deve usar também +=end + +# Primeiro e principal: Tudo é um objeto. + +# Números são objetos + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Um pouco de aritmética básica + +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Aritmética é apenas açúcar sintático +# para chamar um método de um objeto +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Valores especiais são objetos +nil # Nada para ver aqui +true # verdadeiro +false # falso + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Igualdade +1 == 1 #=> true +2 == 1 #=> false + +# Desigualdade +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# além de 'false', 'nil' é o único outro valor falso + +!nil #=> true +!false #=> true +!0 #=> false + +# Mais comparações +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Strings são objects + +'Eu sou uma string'.class #=> String +"Eu também sou uma string".class #=> String + +placeholder = "usar interpolação de string" +"Eu posso #{placeholder} quando estiver usando aspas duplas" +#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas" + +# imprime para output (saída) +puts "Estou imprimindo" + +# Variáveis +x = 25 #=> 25 +x #=> 25 + +# Note que uma atribuição retorna o valor atribuido +# Isso significa que você pode fazer múltiplas atribuições: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Por convenção, use snake_case para nomes de variáveis +snake_case = true + +# Use nomes de variáveis descritivos +caminho_para_a_raiz_do_projeto = '/bom/nome/' +caminho = '/nome/ruim/' + +# Símbolos (são objetos) +# Símbolos são imutáveis, são constantes reutilizáveis representadadas +# internamente por um valor inteiro. Eles são frequentemente usados no +# lugar de strings para transmitir com eficiência os valores específicos +# e significativos + +:pendente.class #=> Symbol + +status = :pendente + +status == :pendente #=> true + +status == 'pendente' #=> false + +status == :aprovado #=> false + +# Arrays + +# Isso é um array +[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Arrays podem conter diferentes tipos de itens + +array = [1, "Oi", false] #=> => [1, "Oi", false] + +# Arrays podem ser indexados +# a partir do começo +array[0] #=> 1 +array[12] #=> nil + +# Como aritmética, o acesso via [var] +# é apenas açúcar sintático +# para chamar o método [] de um objeto +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# a partir do final +array[-1] #=> 5 + +# Com um índice de começo e fim +array[2, 4] #=> [3, 4, 5] + +# Ou com um intervalo de valores +array[1..3] #=> [2, 3, 4] + +# Adicionar a um array como este +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# Hashes são o principal dicionário de Ruby com pares de chaves(keys)/valor(value). +# Hashes são simbolizados com chaves "{}" +hash = {'cor' => 'verde', 'numero' => 5} + +hash.keys #=> ['cor', 'numero'] + +# Hashes podem ser rapidamente pesquisados pela chave (key) +hash['cor'] #=> 'verde' +hash['numero'] #=> 5 + +# Procurar em um hash por uma chave que não existe retorna nil: +hash['nada aqui'] #=> nil + +# Interar sobre hashes com o método #each: +hash.each do |k, v| + puts "#{k} is #{v}" +end + +hash.each do |k, v| + puts "#{k} é #{v}" +end + +# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys) + +novo_hash = {defcon: 3, acao: true} + +novo_hash.keys #=> [:defcon, :acao] + +# Dica: Tanto Arrays quanto Hashes são Enumerable. +# Eles compartilham um monte de métodos úteis como each, map, count e mais + +# Estruturas de controle + +if true + "Se verdadeiro" +elsif false + "else if, opcional" +else + "else, também é opcional" +end + +for contador in 1..5 + puts "interação #{contador}" +end +#=> contador 1 +#=> contador 2 +#=> contador 3 +#=> contador 4 +#=> contador 5 + +# PORÉM +# Ninguém usa para loops +# Use "each" em vez, dessa forma: + +(1..5).each do |contador| + puts "interação #{contador}" +end +#=> contador 1 +#=> contador 2 +#=> contador 3 +#=> contador 4 +#=> contador 5 + +contador = 1 +while contador <= 5 do + puts "interação #{contador}" + contador += 1 +end +#=> contador 1 +#=> contador 2 +#=> contador 3 +#=> contador 4 +#=> contador 5 + +grau = 'B' + +case grau +when 'A' + puts "Um longo caminho a percorrer, pequeno gafanhoto" +when 'B' + puts "Melhor sorte da próxima vez" +when 'C' + puts "Você pode fazer melhor" +when 'D' + puts "Scraping through" +when 'F' + puts "Você falhou" +else + puts "Alternative grading system, eh?" +end + +# Funções + +def dobrar(x) + x * 2 +end + +# Funções (e todos os blocos) retornam implicitamente o valor da última linha +dobrar(2) #=> 4 + +# Parênteses são opicionais onde o resultado é claro +dobrar 3 #=> 6 + +dobrar dobrar 3 #=> 12 + +def somar(x,y) + x + y +end + +# Argumentos de métodos são separados por uma vírgula +somar 3, 4 #=> 7 + +somar(3,4), 5 #=> 12 + +# yield +# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco +# ele pode ser chamado com a palavra chave 'yield' + +def ao_redor + puts "{" + yield + puts "}" +end + +ao_redor { puts 'Olá mundo' } + +# { +# Olá mundo +# } + + +# Define uma classe com a palavra chave 'class' + +class Humano + + # Uma variável de classe. Ela é compartilhada por todas as instâncias dessa classe + @@especies = "H. sapiens" + + # Inicialização básica (contructor) + def initialize(nome, idade=0) + # Atribui o argumento para a variável de instancia "nome" do objeto + @nome = nome + # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos + @idade = idade + end + + # Método básico para atribuir valor + def nome=(nome) + @nome = nome + end + + # Método básico de resgatar valor + def nome + @nome + end + + # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância. + # Ele só pode ser chamado na classe, não na instancia + def self.diz(msg) + puts "#{msg}" + end + + def especies + @@especies + end + +end + + +# Instanciando uma classe +jim = Humano.new("Jim Halpert") + +dwight = Humano.new("Dwight K. Schrute") + +# Vamos chamar um par de métodos +jim.especies #=> "H. sapiens" + +jim.nome #=> "Jim Halpert" + +jim.nome = "Jim Halpert II" #=> "Jim Halpert II" + +jim.nome #=> "Jim Halpert II" + +dwight.especies #=> "H. sapiens" + +dwight.nome #=> "Dwight K. Schrute" + +# Chamar o método de classe +Humano.diz("Oi") #=> "Oi" + +# Uma classe também é objeto em Ruby. Então uma classe pode possuir variável de instância +# Variáveis de classe são compartilhadas entre a classe e todos os seus descendentes. + + +# Classe base +class Humano + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(value) + @@foo = value + end +end + +# classe filha +class Trabalhador < Humano +end + +Humano.foo # 0 +Trabalhador.foo # 0 + +Humano.foo = 2 # 2 +Trabalhador.foo # 2 + +# Uma variável de instância não é compartilhada por suas classes decendentes. + +class Humano + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(value) + @bar = value + end +end + +class Doutor < Humano +end + +Humano.bar # 0 +Doutor.bar # nil + +``` diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown new file mode 100644 index 00000000..e840b8cf --- /dev/null +++ b/pt-br/swift-pt.html.markdown @@ -0,0 +1,500 @@ +--- +language: swift +contributors: + - ["Grant Timmerman", "http://github.com/grant"] + - ["Christopher Bess", "http://github.com/cbess"] +translators: + - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"] +lang: pt-br +filename: learnswift.swift +--- + +Swift é uma linguagem de programação para desenvolvimento de aplicações no iOS e OS X criada pela Apple. Criada para +coexistir com Objective-C e para ser mais resiliente a código com erros, Swift foi apresentada em 2014 na Apple's +developer conference WWDC. Foi construída com o compilador LLVM já incluído no Xcode 6 beta. + +O livro oficial [Swift Programming Language] (https://itunes.apple.com/us/book/swift-programming-language/id881256329) da +Apple já está disponível via IBooks (apenas em inglês). + +Confira também o tutorial completo de Swift da Apple [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), também disponível apenas em inglês. + +```swift +// importa um módulo +import UIKit + +// +// MARK: Noções básicas +// + +// Xcode supporta anotações para seu código e lista elas na barra de atalhos +// MARK: Marca uma sessão +// TODO: Faça algo logo +// FIXME: Conserte esse código + +println("Hello, world") + +// Valores em variáveis (var) podem ter seu valor alterado depois de declarados. +// Valores em constantes (let) NÃO podem ser alterados depois de declarados. + +var myVariable = 42 +let øπΩ = "value" // nomes de variáveis em unicode +let π = 3.1415926 +let convenience = "keyword" // nome de variável contextual +let weak = "keyword"; let override = "another keyword" // comandos podem ser separados por uma ponto e vírgula +let `class` = "keyword" // Crases permitem que palavras-chave seja usadas como nome de variáveis +let explicitDouble: Double = 70 +let intValue = 0007 // 7 +let largeIntValue = 77_000 // 77000 +let label = "some text " + String(myVariable) // Coerção +let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolação de strings + +// Constrói valores específicos +// Utiliza configuração de build -D +#if false + println("Not printed") + let buildValue = 3 +#else + let buildValue = 7 +#endif +println("Build value: \(buildValue)") // Build value: 7 + +/* + Optionals fazem parte da linguagem e permitem que você armazene um + valor `Some` (algo) ou `None` (nada). + + Como Swift requer que todas as propriedades tenham valores, até mesmo nil deve + ser explicitamente armazenado como um valor Optional. + + Optional<T> é uma enum. +*/ +var someOptionalString: String? = "optional" // Pode ser nil +// o mesmo acima, mas ? é um operador pós-fixado (açúcar sintático) +var someOptionalString2: Optional<String> = "optional" + +if someOptionalString != nil { + // Eu não sou nil + if someOptionalString!.hasPrefix("opt") { + println("has the prefix") + } + + let empty = someOptionalString?.isEmpty +} +someOptionalString = nil + +// Optional implicitamente desempacotado (unwrapped) +var unwrappedString: String! = "Valor é esperado." +// o mesmo acima, mas ? é um operador pósfixado (açúcar sintático) +var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Valor é esperado." + +if let someOptionalStringConstant = someOptionalString { + // Tem `Some` (algum) valor, não nil + if !someOptionalStringConstant.hasPrefix("ok") { + // não possui o prefixo + } +} + +// Swift tem suporte para armazenar um valor de qualquer tipo. +// AnyObject == id +// Ao contrário de Objective-C `id`, AnyObject funciona com qualquer valor (Class, Int, struct, etc) +var anyObjectVar: AnyObject = 7 +anyObjectVar = "Mudou o valor para string, não é uma boa prática, mas é possível." + +/* +Comentário aqui + /* + Comentários aninhados também são suportados + */ +*/ + +// +// MARK: Coleções +// + +/* + Tipos Array e Dicionário são structs. Portanto `let` e `var` + também indicam se são mutáveis (var) ou imutáveis (let) quando declarados + com esses tipos. +*/ + +// Array +var shoppingList = ["catfish", "water", "lemons"] +shoppingList[1] = "bottle of water" +let emptyArray = [String]() // imutável +var emptyMutableArray = [String]() // mutável + + +// Dicionário +var occupations = [ + "Malcolm": "Captain", + "kaylee": "Mechanic" +] +occupations["Jayne"] = "Public Relations" +let emptyDictionary = [String: Float]() // imutável +var emptyMutableDictionary = [String: Float]() // mutável + + +// +// MARK: Controle de fluxo +// + +// laço for (array) +let myArray = [1, 1, 2, 3, 5] +for value in myArray { + if value == 1 { + println("One!") + } else { + println("Not one!") + } +} + +// laço for (dicionário) +var dict = ["one": 1, "two": 2] +for (key, value) in dict { + println("\(key): \(value)") +} + +// laço for (alcance) +for i in -1...shoppingList.count { + println(i) +} +shoppingList[1...2] = ["steak", "peacons"] +// use ..< para excluir o último número + +// laço while (enquanto) +var i = 1 +while i < 1000 { + i *= 2 +} + +// laço do-while +do { + println("hello") +} while 1 == 2 + +// Switch +let vegetable = "red pepper" +switch vegetable { +case "celery": + let vegetableComment = "Add some raisins and make ants on a log." +case "cucumber", "watercress": + let vegetableComment = "That would make a good tea sandwich." +case let x where x.hasSuffix("pepper"): + let vegetableComment = "Is it a spicy \(x)?" +default: // required (in order to cover all possible input) + let vegetableComment = "Everything tastes good in soup." +} + + +// +// MARK: Funções +// + +// Funções são tipos de primeira classe, o que significa que eles podem ser aninhados +// em funções e podem ser passados como parâmetros + +// Funções Swift com cabeçalhos doc (formato como reStructedText) +/** +Uma operação de saudação + +- Um bullet em documentos +- Outro bullet + +:param: nome A nome +:param: dia A dia +:returns: Uma string contendo o nome e o dia. +*/ +func greet(name: String, day: String) -> String { + return "Hello \(name), today is \(day)." +} +greet("Bob", "Tuesday") + +// Função que retorna múltiplos items em uma tupla +func getGasPrices() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let pricesTuple = getGasPrices() +let price = pricesTuple.2 // 3.79 +// Ignore valores de Tuplas (ou outros valores) usando _ (underscore) +let (_, price1, _) = pricesTuple // price1 == 3.69 +println(price1 == pricesTuple.1) // true +println("Gas price: \(price)") + +// Número variável de argumentos +func setup(numbers: Int...) { + // é um array + let number = numbers[0] + let argCount = numbers.count +} + +// Passando e retornando funções +func makeIncrementer() -> (Int -> Int) { + func addOne(number: Int) -> Int { + return 1 + number + } + return addOne +} +var increment = makeIncrementer() +increment(7) + +// passagem por referência +func swapTwoInts(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +swapTwoInts(&someIntA, &someIntB) +println(someIntB) // 7 + + +// +// MARK: Closures +// +var numbers = [1, 2, 6] + +// Funções são casos especiais de closures ({}) + +// Exemplo de closure. +// `->` separa argumentos e tipo de retorno +// `in` separa o cabeçalho do closure do seu corpo +numbers.map({ + (number: Int) -> Int in + let result = 3 * number + return result +}) + +// Quando o tipo é conhecido, como abaixo, nós podemos fazer o seguinte +numbers = numbers.map({ number in 3 * number }) +// Ou até mesmo isso +//numbers = numbers.map({ $0 * 3 }) + +print(numbers) // [3, 6, 18] + +// Closure restante +numbers = sorted(numbers) { $0 > $1 } + +print(numbers) // [18, 6, 3] + +// Super atalho, já que o operador < infere os tipos + +numbers = sorted(numbers, < ) + +print(numbers) // [3, 6, 18] + +// +// MARK: Estruturas +// + +// Estruturas e classes tem funcionalidades muito similares +struct NamesTable { + let names: [String] + + // Custom subscript + subscript(index: Int) -> String { + return names[index] + } +} + +// Estruturas possuem um inicializador auto-gerado automático (implícito) +let namesTable = NamesTable(names: ["Me", "Them"]) +//let name = namesTable[2] +//println("Name is \(name)") // Name is Them + +// +// MARK: Classes +// + +// Classes, Estruturas e seus membros possuem três níveis de modificadores de acesso +// Eles são: internal (default), public, private + +public class Shape { + public func getArea() -> Int { + return 0; + } +} + +// Todos os métodos e propriedades de uma classe são públicos. +// Se você só precisa armazenar dados em um objeto estruturado, use `struct` + +internal class Rect: Shape { + var sideLength: Int = 1 + + // Getter e setter personalizado + private var perimeter: Int { + get { + return 4 * sideLength + } + set { + // `newValue` é uma variável implicita disponível para os setters + sideLength = newValue / 4 + } + } + + // Carregue uma propriedade sob demanda (lazy) + // subShape permanece nil (não inicializado) até seu getter ser chamado + lazy var subShape = Rect(sideLength: 4) + + // Se você não precisa de um getter e setter personalizado, + // mas ainda quer roda código antes e depois de configurar + // uma propriedade, você pode usar `willSet` e `didSet` + var identifier: String = "defaultID" { + // o argumento `willSet` será o nome da variável para o novo valor + willSet(someIdentifier) { + print(someIdentifier) + } + } + + init(sideLength: Int) { + self.sideLength = sideLength + // sempre chame super.init por último quand inicializar propriedades personalizadas (custom) + super.init() + } + + func shrink() { + if sideLength > 0 { + --sideLength + } + } + + override func getArea() -> Int { + return sideLength * sideLength + } +} + +// Uma classe básica `Square` que estende `Rect` +class Square: Rect { + convenience init() { + self.init(sideLength: 5) + } +} + +var mySquare = Square() +print(mySquare.getArea()) // 25 +mySquare.shrink() +print(mySquare.sideLength) // 4 + +// Compara instâncias, não é o mesmo que == o qual compara objetos +if mySquare === mySquare { + println("Yep, it's mySquare") +} + + +// +// MARK: Enums +// + +// Enums podem opcionalmente ser de um tipo específico ou não. +// Podem conter métodos do mesmo jeito que classes. + +enum Suit { + case Spades, Hearts, Diamonds, Clubs + func getIcon() -> String { + switch self { + case .Spades: return "♤" + case .Hearts: return "♡" + case .Diamonds: return "♢" + case .Clubs: return "♧" + } + } +} + + +// +// MARK: Protocolos +// + +// `protocol` pode requerer que os tipos que se adequam tenham +// propriedades de instância, métodos, operadores e subscripts. +protocol ShapeGenerator { + var enabled: Bool { get set } + func buildShape() -> Shape +} + +// Protocolos declarados com @objc permitem funções opcionais, +// que permitem verificar a confomidade +@objc protocol TransformShape { + optional func reshaped() + optional func canReshape() -> Bool +} + +class MyShape: Rect { + var delegate: TransformShape? + + func grow() { + sideLength += 2 + + if let allow = self.delegate?.canReshape?() { + // test for delegate then for method + // testa por delegação e então por método + self.delegate?.reshaped?() + } + } +} + + +// +// MARK: Outros +// + +// `extension`s: Adicionam uma funcionalidade extra para um tipo já existente. + +// Square agora "segue" o protocolo `Printable` +extension Square: Printable { + var description: String { + return "Area: \(self.getArea()) - ID: \(self.identifier)" + } +} + +println("Square: \(mySquare)") + +// Você pode também estender tipos embutidos (built-in) +extension Int { + var customProperty: String { + return "This is \(self)" + } + + func multiplyBy(num: Int) -> Int { + return num * self + } +} + +println(7.customProperty) // "This is 7" +println(14.multiplyBy(2)) // 42 + +// Generics: Similar com Java e C#. Use a palavra-chave `where` para +// especificar os requisitos do generics. + +func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { + for (index, value) in enumerate(array) { + if value == valueToFind { + return index + } + } + return nil +} +let foundAtIndex = findIndex([1, 2, 3, 4], 3) +println(foundAtIndex == 2) // true + +// Operadores: +// Operadores personalizados (custom) podem começar com os seguintes caracteres: +// / = - + * % < > ! & | ^ . ~ +// ou +// Unicode math, símbolo, seta, e caracteres tipográficos ou de desenho. +prefix operator !!! {} + +// Um operador de prefixo que triplica o comprimento do lado do quadrado +// quando usado +prefix func !!! (inout shape: Square) -> Square { + shape.sideLength *= 3 + return shape +} + +// valor atual +println(mySquare.sideLength) // 4 + +// Troca o comprimento do lado usando um operador personalizado !!!, aumenta o lado por 3 +!!!mySquare +println(mySquare.sideLength) // 12 + +``` diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown new file mode 100644 index 00000000..76cca567 --- /dev/null +++ b/pt-br/visualbasic-pt.html.markdown @@ -0,0 +1,285 @@ +--- +language: Visual Basic +contributors: + - ["Brian Martin", "http://brianmartin.biz"] +translators: + - ["AdrianoJP", "https://github.com/AdrianoJP"] +lang: pt-br +filename: learnvisualbasic-pt.vb +--- + +```vb +Module Module1 + +module Module1 + + Sub Main () + ' Uma visão geral de console de aplicativos do Visual Basic antes de + ' mergulharmos mais profundamente na linguagem + ' Aspas simples começam comentários. + ' Para Navegar este tutorial dentro do compilador do Visual Basic, + ' eu criei um sistema de navegação. + ' Este sistema de navegação vai ser explicado conforme avançarmos no + ' tutorial, e você vai entender o que isso significa. + Console.Title = (" Saiba X em Y Minutes" ) + Console.WriteLine ( "NAVEGAÇÃO" ) 'Mostrar + Console.ForegroundColor = ConsoleColor.Green + Console.WriteLine ("1. Saída Olá Mundo" ) + Console.WriteLine ("2. Entrada Olá Mundo" ) + Console.WriteLine ("3. Cálculando números inteiros " ) + Console.WriteLine ("4. Calculando números decimais " ) + Console.WriteLine ("5 . Calculadora de Trabalho " ) + Console.WriteLine ("6. Usando Do While Loops " ) + Console.WriteLine ("7. Usando Para While Loops " ) + Console.WriteLine ("8 . Declarações condicionais " ) + Console.WriteLine ("9. Selecione uma bebida" ) + Console.WriteLine ("50 . About" ) + Console.WriteLine ("Por favor, escolha um número da lista acima " ) + Seleção Dim As String = Console.ReadLine + Select A seleção dos casos + Caso "1" 'Output HelloWorld + Console.clear () ' Limpa a aplicação e abre o sub privado + HelloWorldOutput () ' Nome Private Sub, Abre Private Sub + Caso "2" 'Olá entrada + Console.clear ( ) + HelloWorldInput ( ) + Caso de "3" 'Calculando Números Inteiros + Console.clear ( ) + CalculatingWholeNumbers ( ) + Caso "4" ' Números decimais Calculting + Console.clear ( ) + CalculatingDecimalNumbers ( ) + Caso "5" ' Calcculator Trabalho + Console.clear ( ) + WorkingCalculator ( ) + Caso "6" 'Usando Do While Loops + Console.clear ( ) + UsingDoWhileLoops ( ) + Caso de "7" 'Usando pois enquanto Loops + Console.clear ( ) + UsingForLoops ( ) + Caso "8" ' Instruções condicionais + Console.clear ( ) + ConditionalStatement ( ) + Caso "9" "Declaração If / Else + Console.clear ( ) + IfElseStatement () ' Selecione uma bebida + Caso "50" 'Quem caixa de msg + Console.clear ( ) + Console.Title = (" Saiba X em Y Minutos :: Quem " ) + MsgBox (" Este tutorial é de Brian Martin ( @ BrianMartinn " ) + Console.clear ( ) + Main () + Console.ReadLine () + + End Select + End Sub + + ' Um - Eu estou usando números para ajudar com a navegação acima quando eu voltar + ' depois de construí-lo . + + " Nós usamos subs privadas para separar diferentes seções do programa. + Private Sub HelloWorldOutput () + ' Título de aplicativo do console + Console.Title = " Olá Mundo Ouput | Saiba X em Y Minutes" + 'Use Console.Write ("") ou Console.WriteLine ("") para imprimir saídas. + " Seguido por Console.Read () alternativamente Console.ReadLine () + ' Console.ReadLine () imprime a saída para o console. + Console.WriteLine ( "Olá Mundo" ) + Console.ReadLine () + End Sub + + ' Dois + Private Sub HelloWorldInput () + Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes" + ' Variáveis + 'Os dados inseridos por um usuário precisa ser armazenada . + ' As variáveis também começar com um Dim e terminar com um Como VariableType . + + ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa + ' Responder ao que é dito. + Nome de usuário Dim As String + " Nós usamos string como string é uma variável de texto baseado . + Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome. + username = Console.ReadLine () ' armazena o nome usuários. + Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome ' + Console.ReadLine () ' Outsputs acima. + ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta. + " Outras variáveis incluem Integer e usamos inteiro para números inteiros. + End Sub + + "Três + Sub CalculatingWholeNumbers particulares () + Console.Title = " Cálculo de Números Inteiros | Saiba X em Y Minutes" + Console.Write ("Primeiro número:") 'Digite um número inteiro, 1, 2, 50, 104 ect + Dim a As Integer = Console.ReadLine () + Console.Write ("Segundo número:") 'Enter segundo número inteiro. + Dim b As Integer = Console.ReadLine () + Dim c As Integer = a + b + Console.WriteLine ( c) + Console.ReadLine () + " O texto acima é uma calculadora simples + End Sub + + 'Quatro + Sub CalculatingDecimalNumbers particulares () + Console.Title = " Calculando com duplo | Saiba X em Y Minutes" + ' Claro que gostaria de ser capaz de somar decimais . + " Por isso, poderia mudar o acima de Integer para Double. + + " Digite um número inteiro , 1,2 , 2,4 , 50,1 , 104,9 ect + Console.Write ("Primeiro número:") + Dim a As Double = Console.ReadLine + Console.Write ("Segundo número:") 'Enter segundo número inteiro. + Dim b As Double = Console.ReadLine + Dim c As Double = a + b + Console.WriteLine ( c) + Console.ReadLine () + " Portanto, o programa acima pode adicionar até 1,1-2,2 + End Sub + + ' Cinco + Private Sub WorkingCalculator () + Console.Title = " A Calculadora de Trabalho | Saiba X em Y Minutes" + " No entanto, se você gostaria que a calculadora para subtrair, dividir , múltiplos e + ' somar. + ' Copie e cole o código acima novamente . + Console.Write ("Primeiro número:") + Dim a As Double = Console.ReadLine + Console.Write ("Segundo número:") 'Enter segundo número inteiro. + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + " Ao adicionar as linhas abaixo , somos capazes de calcular a subtração , + ' multply bem como dividir os valores de a e b + Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) ) + 'Queremos pad as respostas para a esquerda por três espaços. + Console.WriteLine (" =" + c.ToString.PadLeft (3) ) + Console.Gravar ( a.ToString ( ) + " * " + b.ToString ( ) ) + Console.WriteLine (" =" + d.ToString.PadLeft (3) ) + Console.Gravar ( a.ToString ( ) + " - " + b.ToString ( ) ) + Console.WriteLine (" =" + e.ToString.PadLeft (3) ) + Console.Write ( a.ToString () + "/" + b.ToString ()) + Console.WriteLine (" =" + e.ToString.PadLeft (3) ) + Console.ReadLine () + + End Sub + + ' Seis + Sub UsingDoWhileLoops particulares () + ' Assim como o sub privado anterior + ' Desta vez, perguntar se o usuário deseja continuar ( Sim ou Não ? ) + ' Estamos usando Do While Loop , como não temos certeza se o usuário quer usar o + 'programa mais de uma vez . + Console.Title = " UsingDoWhileLoops | Saiba X em Y Minutes" + Dim resposta As String ' Nós usamos a variável " String" como a resposta é um texto + Do ' Começamos o programa com + Console.Write ("Primeiro número:") + Dim a As Double = Console.ReadLine + Console.Write ("Segundo número:") + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) ) + Console.WriteLine (" =" + c.ToString.PadLeft (3) ) + Console.Gravar ( a.ToString ( ) + " * " + b.ToString ( ) ) + Console.WriteLine (" =" + d.ToString.PadLeft (3) ) + Console.Gravar ( a.ToString ( ) + " - " + b.ToString ( ) ) + Console.WriteLine (" =" + e.ToString.PadLeft (3) ) + Console.Write ( a.ToString () + "/" + b.ToString ()) + Console.WriteLine (" =" + e.ToString.PadLeft (3) ) + Console.ReadLine () + ' Faça a pergunta , se o usuário deseja continuar? Infelizmente, + "é sensível a maiúsculas. + Console.Write ( "Deseja continuar? (Sim / não )") + " O programa pega a variável e imprime e começa de novo. + answer = Console.ReadLine + " O comando para a variável para trabalhar seria , neste caso, " sim " + Loop While resposta = "yes" + + End Sub + + ' Sete + Sub UsingForLoops particulares () + ' Às vezes, o programa só precisa ser executado uma vez. + " Neste programa vamos estar em contagem regressiva a partir de 10. + + Console.Title = " Usando Para Loops | Saiba X em Y Minutes" + 'Declare variável e qual o número que deve contar para baixo na etapa 1, + ' Passo -2, -3 Passo ect. + Para i As Integer = 10 para 0 passo -1 + Console.WriteLine ( i.ToString ) ' Imprime o valor do contador + Next i ' Calcular novo valor + Console.WriteLine ( "Start ") ' Vamos começar o bebê programa ! + Console.ReadLine () ' POW ! - Talvez eu fiquei um pouco animado, então :) + End Sub + + ' Oito + Private Sub ConditionalStatement () + Console.Title = " Instruções condicionais | Saiba X em Y Minutes" + UserName Dim As String = Console.ReadLine + Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome. + username = Console.ReadLine () ' armazena o nome usuários. + Se userName = " Adam " Então + Console.WriteLine (" Olá Adam " ) + Console.WriteLine (" Obrigado por criar este site útil " ) + Console.ReadLine () + outro + Console.WriteLine (" Olá " + nome do usuário) + Console.WriteLine (" Você check-out www.learnxinyminutes.com " ) + Console.ReadLine () ' Fins e imprime a declaração acima . + End If + End Sub + + 'Nove + Private Sub IfElseStatement () + Console.Title = "Se Declaração / Else | Saiba X em Y Minutes" + 'Às vezes é importante ter em conta mais de duas alternativas. + 'Às vezes, há um bom número de outros. + 'Quando este for o caso , mais do que uma if seria necessária . + 'Uma instrução if é ótimo para máquinas de venda automática . Quando o usuário digita um código. + ' A1 , A2, A3 , ect para selecionar um item. + 'Todas as opções podem ser combinadas em uma única if. + + Seleção Dim Valor String = Console.ReadLine ' para a seleção + Console.WriteLine (" A1. Para Soda " ) + Console.WriteLine (" A2. Para Fanta " ) + Console.WriteLine (" A3 . Para Guaraná" ) + Console.WriteLine (" A4. Para Coca Diet" ) + Console.ReadLine () + Se a seleção = "A1" Então + Console.WriteLine (" soda " ) + Console.ReadLine () + Seleção ElseIf = " A2 " Então + Console.WriteLine (" fanta " ) + Console.ReadLine () + Seleção ElseIf = " A3 " Então + Console.WriteLine ( "guaraná" ) + Console.ReadLine () + Seleção ElseIf = " A4 " Então + Console.WriteLine ( "coca diet" ) + Console.ReadLine () + outro + Console.WriteLine (" Por favor seleccione um produto" ) + Console.ReadLine () + End If + + End Sub + +End Module + +``` + +##Referências + +Aprendi Visual Basic no aplicativo de console. Isso me permitiu entender os princípios da programação de computador para continuar a aprender outras linguagens de programação facilmente. + +Eu criei um tutorial mais aprofundado do <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic</a> para aqueles que gostariam de saber mais. + +Toda a sintaxe deste tutorial é válida. Copie e cole o código no compilador do Visual Basic e execute (com o F5) o programa. diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown new file mode 100644 index 00000000..f347f8ef --- /dev/null +++ b/pt-br/xml-pt.html.markdown @@ -0,0 +1,133 @@ +--- +language: xml +filename: learnxml-pt.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +XML é uma linguagem de marcação projetada para armazenar e transportar dados. + +Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, +basta carregá-lo. + +* Sintaxe XML + +```xml +<!-- Comentários em XML são feitos desta forma --> + +<?xml version="1.0" encoding="UTF-8"?> +<livraria> + <livro category="COZINHA"> + <titulo lang="en">Everyday Italian</titulo> + <autor>Giada De Laurentiis</autor> + <year>2005</year> + <preco>30.00</preco> + </livro> + <livro category="CRIANÇAS"> + <titulo lang="en">Harry Potter</titulo> + <autor>J K. Rowling</autor> + <year>2005</year> + <preco>29.99</preco> + </livro> + <livro category="WEB"> + <titulo lang="en">Learning XML</titulo> + <autor>Erik T. Ray</autor> + <year>2003</year> + <preco>39.95</preco> + </livro> +</livraria> + +<!-- Um típico arquivo XML é mostrado acima. + Ele começa com uma declaração, informando alguns metadados (opcional). + + XML usa uma estrutura de árvore. Acima, o nó raiz é "Livraria", que tem + três nós filhos, todos os 'Livros'. Esses nós tem mais nós filhos, + e assim por diante... + + Nós são criados usando tags abre/fecha, filhos são justamente os nós que + estão entre estes nós. --> + + +<!-- XML traz dois tipos de dados: + 1 - Atributos -> Isso é metadados sobre um nó. + Normalmente, o parser XML usa esta informação para armazenar os dados + corretamente. Caracteriza-se por aparecer em parênteses dentro da tag + de abertura. + 2 - Elementos -> É dados puros. + Isso é o que o analisador irá recuperar a partir do arquivo XML. + Elementos aparecem entre as tags de abertura e fechamento, + sem parênteses. --> + + +<!-- Abaixo, um elemento com dois atributos --> +<arquivo type="gif" id="4293">computer.gif</arquivo> + + +``` + +* Documento bem formatado x Validação + +Um documento XML é bem formatado se estiver sintaticamente correto.No entanto, +é possível injetar mais restrições no documento, utilizando definições de +documentos, tais como DTD e XML Schema. + +Um documento XML que segue uma definição de documento é chamado válido, sobre +esse documento. + +Com esta ferramenta, você pode verificar os dados XML fora da lógica da aplicação. + +```xml + +<!-- Abaixo, você pode ver uma versão simplificada do documento livraria, +com a adição de definição DTD.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "livraria.dtd"> +<livraria> + <livro category="COOKING"> + <titulo >Everyday Italian</titulo> + <preco>30.00</preco> + </livro> +</livraria> + +<!-- Este DTD poderia ser algo como:--> + +<!DOCTYPE note +[ +<!ELEMENT livraria (livro+)> +<!ELEMENT livro (titulo,preco)> +<!ATTLIST livro category CDATA "Literature"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT preco (#PCDATA)> +]> + + +<!-- O DTD começa com uma declaração. + Na sequência, o nó raiz é declarado, o que requer uma ou mais crianças nós + 'Livro'. Cada 'Livro' deve conter exatamente um 'titulo' e um 'preco' e um + atributo chamado "categoria", com "Literatura", como o valor padrão. + Os nós "título" e "preço" contêm um conjunto de dados de caráter analisados.--> + +<!-- O DTD poderia ser declarado dentro do próprio arquivo XML .--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT livraria (livro+)> +<!ELEMENT livro (titulo,preco)> +<!ATTLIST livro category CDATA "Literature"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT preco (#PCDATA)> +]> + +<livraria> + <livro category="COOKING"> + <titulo >Everyday Italian</titulo> + <preco>30.00</preco> + </livro> +</livraria> +``` diff --git a/pt-pt/brainfuck-pt.html.markdown b/pt-pt/brainfuck-pt.html.markdown new file mode 100644 index 00000000..da4c787f --- /dev/null +++ b/pt-pt/brainfuck-pt.html.markdown @@ -0,0 +1,84 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Joao Marques", "http://github.com/mrshankly"] +lang: pt-pt +--- + +Brainfuck (não capitalizado excepto no início de uma frase) é uma linguagem de +programação Turing-completa extremamente simples com apenas 8 comandos. + +``` +Qualquer caractere excepto "><+-.,[]" (não contar com as aspas) é ignorado. + +Brainfuck é representado por um vector com 30 000 células inicializadas a zero +e um ponteiro de dados que aponta para a célula actual. + +Existem 8 comandos: ++ : Incrementa o valor da célula actual em 1. +- : Decrementa o valor da célula actual 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). +. : Imprime o valor ASCII da célula actual. (ex. 65 = 'A'). +, : Lê um único caractere para a célula actual. +[ : Se o valor da célula actual for zero, salta para o ] correspondente. + Caso contrário, passa para a instrução seguinte. +] : Se o valor da célula actual for zero, passa para a instrução seguinte. + Caso contrário, volta para a instrução relativa ao [ correspondente. + +[ e ] formam um ciclo while. Obviamente, devem ser equilibrados. + +Vejamos alguns programas básicos de brainfuck. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6. +A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se +o ponteiro de dados para a célula #2. Incrementa-se o valor da célula #2 10 +vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se +a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para +a célula #1 chegar a 0, momento em que se salta para o ] correspondente, +continuando com a instrução seguinte). + +Nesta altura encontramo-nos na célula #1, cujo valor é 0, enquanto a célula #2 +tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5 +vezes para um valor final de 65, é então impresso o valor da célula #2. Ao valor +65 corresponde o caractere 'A' em ASCII, 'A' é então impresso para o terminal. + +, [ > + < - ] > . + +Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é +iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na +célula #2, movemos o ponteiro de dados de volta para a célula #1, finalmente +decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser +igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de +dados está a apontar para a célula #1 no fim do ciclo, movemos o ponteiro para a +célula #2 e imprimimos o valor em ASCII. + +Os espaços servem apenas para tornar o programa mais legível. Podemos escrever +o mesmo programa da seguinte maneira: + +,[>+<-]>. + +Tenta descobrir o que este programa faz: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Este programa lê dois números e multiplica-os. + +Basicamente o programa pede dois caracteres ao utilizador. Depois é iniciado um +ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados +para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula +#2, incrementando o valor da célula #3. Contudo, existe um problema, no final do +ciclo interior a célula #2 tem o valor 0. Para resolver este problema o valor da +célula #4 é também incrementado e copiado para a célula #2. +``` + +Fica então explicado brainfuck. Simples, não? Por divertimento podes escrever os +teus próprios programas em brainfuck, ou então escrever um interpretador de +brainfuck noutra linguagem. O interpretador é relativamente fácil de se +implementar, mas se fores masoquista, tenta escrever um interpretador de +brainfuck… em brainfuck. diff --git a/pt-pt/git-pt.html.markdown b/pt-pt/git-pt.html.markdown new file mode 100644 index 00000000..a85c9704 --- /dev/null +++ b/pt-pt/git-pt.html.markdown @@ -0,0 +1,415 @@ +--- +category: tool +tool: git +lang: pt-pt +filename: LearnGit.txt +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["Rafael Jegundo", "http://rafaeljegundo.github.io/"] +--- + +Git é um sistema distribuido de gestão para código fonte e controlo de versões. + +Funciona através de uma série de registos de estado do projecto e usa esse +registo para permitir funcionalidades de versionamento e gestão de código +fonte. + +## Conceitos de versionamento + +### O que é controlo de versões + +Controlo de versões (*source control*) é um processo de registo de alterações +a um ficheiro ou conjunto de ficheiros ao longo do tempo. + +### Controlo de versões: Centralizado VS Distribuido + +* Controlo de versões centralizado foca-se na sincronização, registo e *backup* +de ficheiros. +* Controlo de versões distribuido foca-se em partilhar alterações. Cada +alteração é associada a um *id* único. +* Sistemas distribuidos não têm estrutura definida. É possivel ter um sistema +centralizado ao estilo SVN usando git. + +[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### Porquê usar git? + +* Permite trabalhar offline. +* Colaborar com outros é fácil! +* Criar *branches* é fácil! +* Fazer *merge* é fácil! +* Git é rápido. +* Git é flexivel. + +## Git - Arquitectura + + +### Repositório + +Um conjunto de ficheiros, directórios, registos históricos, *commits* e +referências. Pode ser imaginado como uma estrutura de dados de código fonte +com a particularidade de cada elemento do código fonte permitir acesso ao +histórico das suas alterações, entre outras coisas. + +Um repositório git é constituido pelo directório .git e a *working tree* + +### Directório .git (componente do repositório) + +O repositório .git contém todas as configurações, *logs*, *branches*, +referências e outros. + +[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### *Working Tree* (componente do repositório) + +Isto é basicamente os directórios e ficheiros do repositório. É frequentemente +referido como o directório do projecto. + +### *Index* (componente do directório .git) + +O *Index* é a camada de interface no git. Consistente num elemento que separa +o directório do projecto do repositório git. Isto permite aos programadores um +maior controlo sobre o que é registado no repositório git. + +### *Commit* + +Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos ficheiros do projecto. +Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações +serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado +para outros repositórios ou não! + +### *Branch* + +Um *branch* é essencialmente uma referência que aponta para o último *commit* +efetuado. À medida que são feitos novos commits, esta referência é atualizada +automaticamente e passa a apontar para o commit mais recente. + +### *HEAD* e *head* (componentes do directório .git) + +*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem +uma *HEAD* activa. +*head* é uma referência que aponta para qualquer *commit*. Um repositório pode +ter um número indefinido de *heads* + +### Recursos conceptuais (EN) + +* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/) +* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html) + +## Comandos + +### *init* + +Cria um repositório Git vazio. As definições, informação guardada e outros do +repositório git são guardados num directório (pasta) denominado ".git". + +```bash +$ git init +``` + +### *config* + +Permite configurar as definições, sejam as definições do repositório, sistema +ou configurações globais. + +```bash +# Imprime e define algumas variáveis de configuração básicas (global) +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config) + +### help + +Para aceder rapidamente a um guia extremamente detalhada sobre cada comando. +Ou para dar apenas uma lembraça rápida de alguma semântica. + +```bash +# Ver rapidamente os comandos disponiveis +$ git help + +# Ver todos os comandos disponiveis +$ git help -a + +# Requerer *help* sobre um comando especifico - manual de utilizador +# git help <command_here> +$ git help add +$ git help commit +$ git help init +``` + +### status + +Apresenta as diferenças entre o ficheiro *index* (no fundo a versão corrente +do repositório) e o *commit* da *HEAD* atual. + + +```bash +# Apresenta o *branch*, ficheiros não monitorizados, alterações e outras +# difereças +$ git status + +# Para aprender mais detalhes sobre git *status* +$ git help status +``` + +### add + +Adiciona ficheiros ao repositório corrente. Se os ficheiros novos não forem +adicionados através de `git add` ao repositório, então eles não serão +incluidos nos commits! + +```bash +# adiciona um ficheiro no directório do projecto atual +$ git add HelloWorld.java + +# adiciona um ficheiro num sub-directório +$ git add /path/to/file/HelloWorld.c + +# permite usar expressões regulares! +$ git add ./*.java +``` + +### branch + +Gere os *branches*. É possível ver, editar, criar e apagar branches com este +comando. + +```bash +# listar *branches* existentes e remotos +$ git branch -a + +# criar um novo *branch* +$ git branch myNewBranch + +# apagar um *branch* +$ git branch -d myBranch + +# alterar o nome de um *branch* +# git branch -m <oldname> <newname> +$ git branch -m myBranchName myNewBranchName + +# editar a descrição de um *branch* +$ git branch myBranchName --edit-description +``` + +### checkout + +Atualiza todos os ficheiros no directório do projecto de forma a ficarem iguais +à versão do index ou do *branch* especificado. + +```bash +# Checkout de um repositório - por predefinição para o branch master +$ git checkout +# Checkout de um branch especifico +$ git checkout branchName +# Cria um novo branch e faz checkout para ele. +# Equivalente a: "git branch <name>; git checkout <name>" +$ git checkout -b newBranch +``` + +### clone + +Clona ou copia um repositório existente para um novo directório. Também +adiciona *branches* de monitorização remota para cada *branch* no repositório +clonado o que permite enviar alterações para um *branch* remoto. + +```bash +# Clona learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git +``` + +### commit + +Guarda o conteudo atual do index num novo *commit*. Este *commit* contém +as alterações feitas e a mensagem criada pelo utilizador. + +```bash +# commit com uma mensagem +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +``` + +### diff + +Apresenta as diferenças entre um ficheiro no repositório do projecto, *index* +e *commits* + +```bash +# Apresenta a diferença entre o directório atual e o index +$ git diff + +# Apresenta a diferença entre o index e os commits mais recentes +$ git diff --cached + +# Apresenta a diferença entre o directório atual e o commit mais recente +$ git diff HEAD +``` + +### grep + +Permite procurar facilmente num repositório + +Configurações opcionais: + +```bash +# Obrigado a Travis Jeffery por estas +# Define a apresentação de números de linha nos resultados do grep +$ git config --global grep.lineNumber true + +# Torna os resultados da pesquisa mais fáceis de ler, agrupando-os +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Pesquisa por "variableName" em todos os ficheiros de java +$ git grep 'variableName' -- '*.java' + +# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove" +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +Google é teu amigo; para mais exemplos: +[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Apresenta commits do repositório. + +```bash +# Apresenta todos os commits +$ git log + +# Apresenta X commits +$ git log -n 10 + +# Apresenta apenas commits de merge +$ git log --merges +``` + +### merge + +"Merge" (junta) as alterações de commits externos com o *branch* atual. + +```bash +# Junta o branch especificado com o atual +$ git merge branchName + +# Para gerar sempre um commit ao juntar os branches +$ git merge --no-ff branchName +``` + +### mv + +Alterar o nome ou mover um ficheiro. + +```bash +# Alterar o nome de um ficheiro +$ git mv HelloWorld.c HelloNewWorld.c + +# Mover um ficheiro +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Forçar a alteração de nome ou mudança local +# "existingFile" já existe no directório, será sobre-escrito. +$ git mv -f myFile existingFile +``` + +### pull + +Puxa alterações de um repositório e junta-as com outro branch + +```bash +# Atualiza o repositório local, juntando as novas alterações +# do repositório remoto 'origin' e branch 'master' +# git pull <remote> <branch> +# git pull => aplica a predefinição => git pull origin master +$ git pull origin master + +# Juntar alterações do branch remote e fazer rebase commits do branch +# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>" +$ git pull origin master --rebase +``` + +### push + +Enviar e juntar alterações de um branch para o seu branch correspondente +num repositório remoto. + +```bash +# Envia e junta as alterações de um repositório local +# para um remoto denominado "origin" no branch "master". +# git push <remote> <branch> +# git push => aplica a predefinição => git push origin master +$ git push origin master +``` + +### rebase (cautela!) + +Pega em todas as alterações que foram registadas num branch e volta a +aplicá-las em outro branch. +*Não deve ser feito rebase de commits que foram enviados para um repositório +público* + +```bash +# Faz Rebase de experimentBranch para master +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[Additional Reading (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (cautela!) + +Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*, +*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também +perigoso se não há certeza quanto ao que se está a fazer. + +```bash +# Restabelece a camada intermediária de registo para o último +# commit (o directório fica sem alterações) +$ git reset + +# Restabelece a camada intermediária de registo para o último commit, e +# sobre-escreve o projecto atual +$ git reset --hard + +# Move a head do branch atual para o commit especificado, sem alterar o projecto. +# todas as alterações ainda existem no projecto +$ git reset 31f2bb1 + +# Inverte a head do branch atual para o commit especificado +# fazendo com que este esteja em sintonia com o directório do projecto +# Remove alterações não registadas e todos os commits após o commit especificado +$ git reset --hard 31f2bb1 +``` + +### rm + +O oposto de git add, git rm remove ficheiros do branch atual. + +```bash +# remove HelloWorld.c +$ git rm HelloWorld.c + +# Remove um ficheiro de um sub-directório +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## Informação complementar (EN) + +* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) + +* [git-scm - Video Tutorials](http://git-scm.com/videos) + +* [git-scm - Documentation](http://git-scm.com/docs) + +* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/purescript.html.markdown b/purescript.html.markdown new file mode 100644 index 00000000..a006cdff --- /dev/null +++ b/purescript.html.markdown @@ -0,0 +1,195 @@ +--- +language: purescript +contributors: + - ["Fredrik Dyrkell", "http://www.lexicallyscoped.com"] +--- + +PureScript is a small strongly, statically typed language compiling to Javascript. + +* Learn more at [http://www.purescript.org/](http://www.purescript.org/) +* Documentation: [http://docs.purescript.org/en/latest/](http://docs.purescript.org/en/latest/) +* Book: Purescript by Example, [https://leanpub.com/purescript/](https://leanpub.com/purescript/) + +```haskell + +-- +-- 1. Primitive datatypes that corresponds to their Javascript +-- equivalents at runtime. + +-- Numbers +1 + 7*5 :: Number -- 36 +-- Types are inferred, so the following works fine +9 / 2.5 + 4.4 -- 8 +-- Hexadecimal literals +0xff + 1 -- 256 +-- Unary negation +6 * -3 -- -18 +6 * negate 3 -- -18 +-- Modulus +3 % 2 -- 1 +4 % 2 -- 0 +-- Inspect the type of an expression in psci +:t 9 / 2.5 + 4.4 -- Prim.Number + +-- Booleans +true :: Boolean -- true +false :: Boolean -- false +-- Negation +not true --false +23 == 23 -- true +1 /= 4 -- true +1 >= 4 -- false +-- Comparisions < <= > >= +-- are defined in terms of compare +compare 1 2 -- LT +compare 2 2 -- EQ +compare 3 2 -- GT +-- Conjunction and Disjunction +true && (9 >= 19 || 1 < 2) -- true + +-- Strings +"Hellow" :: String -- "Hellow" +-- Multiline string +"Hellow\ +\orld" -- "Helloworld" +-- Concatenate +"such " ++ "amaze" -- "such amaze" + +-- +-- 2. Arrays are Javascript arrays, but must be homogeneous + +[1,1,2,3,5,8] :: [Number] -- [1,1,2,3,5,8] +[true, true, false] :: [Boolean] -- [true,true,false] +-- [1,2, true, "false"] won't work +-- `Cannot unify Prim.Number with Prim.Boolean` +-- Cons (prepend) +1 : [2,4,3] -- [1,2,4,3] + +-- Requires purescript-arrays (Data.Array) +-- and purescript-maybe (Data.Maybe) + +-- Safe access return Maybe a +head [1,2,3] -- Just (1) +tail [3,2,1] -- Just ([2,1]) +init [1,2,3] -- Just ([1,2]) +last [3,2,1] -- Just (1) +-- Random access - indexing +[3,4,5,6,7] !! 2 -- Just (5) +-- Range +1..5 -- [1,2,3,4,5] +length [2,2,2] -- 3 +drop 3 [5,4,3,2,1] -- [2,1] +take 3 [5,4,3,2,1] -- [5,4,3] +append [1,2,3] [4,5,6] -- [1,2,3,4,5,6] + +-- +-- 3. Records are Javascript objects, with zero or more fields, which +-- can have different types +let book = {title: "Foucault's pendulum", author: "Umberto Eco"} +-- Access properties +book.title -- "Foucault's pendulum" + +getTitle b = b.title +-- Works on all records with a title (but doesn't require any other field) +getTitle book -- "Foucault's pendulum" +getTitle {title: "Weekend in Monaco", artist: "The Rippingtons"} -- "Weekend in Monaco" +-- Update a record +changeTitle b t = b {title = t} +changeTitle book "Ill nome della rosa" -- {title: "Ill nome della + -- rosa", author: "Umberto Eco"} + +-- +-- 4. Functions +sumOfSquares x y = x*x+y*y +sumOfSquares 3 4 -- 25 +-- In psci you have to write `let` in front of the function to get a +-- top level binding +mod x y = x % y +mod 3 2 -- 1 +-- Infix application of function +3 `mod` 2 -- 1 + +-- function application have higher precedence than all other +-- operators +sumOfSquares 3 4 * sumOfSquares 4 5 -- 1025 + +-- Conditional +abs' n = if n>=0 then n else -n +abs' (-3) -- 3 + +-- Guarded equations +abs n | n >= 0 = n + | otherwise = -n + +-- Pattern matching + +-- Note the type signature, input is an array of numbers The pattern +-- matching destructures and binds the array into parts +first :: [Number] -> Number +first (x:_) = x +first [3,4,5] -- 3 +second :: [Number] -> Number +second (_:y:_) = y +second [3,4,5] -- 4 +sumTwo :: [Number] -> [Number] +sumTwo (x:y:rest) = (x+y) : rest +sumTwo [2,3,4,5,6] -- [5,4,5,6] + +-- sumTwo doesn't handle when the array is empty or just have one +-- element in which case you get an error +sumTwo [1] -- Failed pattern match + +-- Complementing patterns to match +-- Good ol' Fibonacci +fib 1 = 1 +fib 2 = 2 +fib x = fib (x-1) + fib (x-2) +fib 10 -- 89 + +-- Use underscore to match any, where you don't care about the binding name +isZero 0 = true +isZero _ = false + +-- Pattern matching on records +ecoTitle {author = "Umberto Eco", title = t} = Just t +ecoTitle _ = Nothing + +ecoTitle book -- Just ("Foucault's pendulum") +ecoTitle {title: "The Quantum Thief", author: "Hannu Rajaniemi"} -- Nothing +-- ecoTitle requires both field to type check: +ecoTitle {title: "The Quantum Thief"} -- Object does not have property author + +-- Lambda expressions +(\x -> x*x) 3 -- 9 +(\x y -> x*x + y*y) 4 5 -- 41 +sqr = \x -> x*x + +-- Currying +add x y = x + y -- is equivalent with +add = \x -> (\y -> x+y) +add3 = add 3 +:t add3 -- Prim.Number -> Prim.Number + +-- Forward and backward function composition +-- drop 3 followed by taking 5 +(drop 3 >>> take 5) (1..20) -- [4,5,6,7,8] +-- take 5 followed by dropping 3 +(drop 3 <<< take 5) (1..20) -- [4,5] + +-- Operations using higher order functions +even x = x % 2 == 0 +filter even (1..10) -- [2,4,6,8,10] +map (\x -> x+11) (1..5) -- [12,13,14,15,16] + +-- Requires purescript-foldable-traversabe (Data.Foldable) + +foldr (+) 0 (1..10) -- 55 +sum (1..10) -- 55 +product (1..10) -- 3628800 + +-- Testing with predicate +any even [1,2,3] -- true +all even [1,2,3] -- false + +``` + diff --git a/python.html.markdown b/python.html.markdown index e7ee6fbd..5572e38e 100644 --- a/python.html.markdown +++ b/python.html.markdown @@ -2,22 +2,26 @@ language: python contributors: - ["Louie Dinh", "http://ldinh.ca"] + - ["Amin Bandali", "http://aminbandali.com"] + - ["Andre Polykanine", "https://github.com/Oire"] filename: learnpython.py --- -Python was created by Guido Van Rossum in the early 90's. It is now one of the most popular -languages in existence. I fell in love with Python for its syntactic clarity. Its basically +Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular +languages in existence. I fell in love with Python for its syntactic clarity. It's basically executable pseudocode. Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service] Note: This article applies to Python 2.7 specifically, but should be applicable -to Python 2.x. Look for another tour of Python 3 soon! +to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/). ```python -# Single line comments start with a hash. + +# Single line comments start with a number symbol. + """ Multiline strings can be written - using three "'s, and are often used + using three "s, and are often used as comments """ @@ -26,60 +30,85 @@ to Python 2.x. Look for another tour of Python 3 soon! #################################################### # You have numbers -3 #=> 3 +3 # => 3 # Math is what you would expect -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 -35 / 5 #=> 7 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7 # Division is a bit tricky. It is integer division and floors the results # automatically. -5 / 2 #=> 2 +5 / 2 # => 2 # To fix division we need to learn about floats. 2.0 # This is a float -11.0 / 4.0 #=> 2.75 ahhh...much better +11.0 / 4.0 # => 2.75 ahhh...much better + +# Result of integer division truncated down both for positive and negative. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # works on floats too +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Modulo operation +7 % 3 # => 1 + +# Exponentiation (x to the yth power) +2**4 # => 16 # Enforce precedence with parentheses -(1 + 3) * 2 #=> 8 +(1 + 3) * 2 # => 8 -# Boolean values are primitives -True -False +# Boolean Operators +# Note "and" and "or" are case-sensitive +True and False #=> False +False or True #=> True + +# Note using Bool operators with ints +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True # negate with not -not True #=> False -not False #=> True +not True # => False +not False # => True # Equality is == -1 == 1 #=> True -2 == 1 #=> False +1 == 1 # => True +2 == 1 # => False # Inequality is != -1 != 1 #=> False -2 != 1 #=> True +1 != 1 # => False +2 != 1 # => True # More comparisons -1 < 10 #=> True -1 > 10 #=> False -2 <= 2 #=> True -2 >= 2 #=> True +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True -# Comparisons can be chained ! -1 < 2 < 3 #=> True -2 < 3 < 2 #=> False +# Comparisons can be chained! +1 < 2 < 3 # => True +2 < 3 < 2 # => False # Strings are created with " or ' "This is a string." 'This is also a string.' # Strings can be added too! -"Hello " + "world!" #=> "Hello world!" +"Hello " + "world!" # => "Hello world!" +# Strings can be added without using '+' +"Hello " "world!" # => "Hello world!" + +# ... or multiplied +"Hello" * 3 # => "HelloHelloHello" # A string can be treated like a list of characters -"This is a string"[0] #=> 'T' +"This is a string"[0] # => 'T' # % can be used to format strings, like this: "%s can be %s" % ("strings", "interpolated") @@ -91,12 +120,12 @@ not False #=> True "{name} wants to eat {food}".format(name="Bob", food="lasagna") # None is an object -None #=> None +None # => None -# Don't use the equality `==` symbol to compare objects to None -# Use `is` instead -"etc" is None #=> False -None is None #=> True +# Don't use the equality "==" symbol to compare objects to None +# Use "is" instead +"etc" is None # => False +None is None # => True # The 'is' operator tests for object identity. This isn't # very useful when dealing with primitive values, but is @@ -104,28 +133,27 @@ None is None #=> True # None, 0, and empty strings/lists all evaluate to False. # All other values are True -0 == False #=> True -"" == False #=> True +bool(0) # => False +bool("") # => False #################################################### ## 2. Variables and Collections #################################################### -# Printing is pretty easy +# Python has a print statement print "I'm Python. Nice to meet you!" - # No need to declare variables before assigning to them. some_var = 5 # Convention is to use lower_case_with_underscores -some_var #=> 5 +some_var # => 5 # Accessing a previously unassigned variable is an exception. # See Control Flow to learn more about exception handling. some_other_var # Raises a name error # if can be used as an expression -"yahoo!" if 3 > 2 else 2 #=> "yahoo!" +"yahoo!" if 3 > 2 else 2 # => "yahoo!" # Lists store sequences li = [] @@ -133,57 +161,68 @@ li = [] other_li = [4, 5, 6] # Add stuff to the end of a list with append -li.append(1) #li is now [1] -li.append(2) #li is now [1, 2] -li.append(4) #li is now [1, 2, 4] -li.append(3) #li is now [1, 2, 4, 3] +li.append(1) # li is now [1] +li.append(2) # li is now [1, 2] +li.append(4) # li is now [1, 2, 4] +li.append(3) # li is now [1, 2, 4, 3] # Remove from the end with pop -li.pop() #=> 3 and li is now [1, 2, 4] +li.pop() # => 3 and li is now [1, 2, 4] # Let's put it back li.append(3) # li is now [1, 2, 4, 3] again. # Access a list like you would any array -li[0] #=> 1 +li[0] # => 1 +# Assign new values to indexes that have already been initialized with = +li[0] = 42 +li[0] # => 42 +li[0] = 1 # Note: setting it back to the original value # Look at the last element -li[-1] #=> 3 +li[-1] # => 3 # Looking out of bounds is an IndexError -li[4] # Raises an IndexError +li[4] # Raises an IndexError # You can look at ranges with slice syntax. # (It's a closed/open range for you mathy types.) -li[1:3] #=> [2, 4] +li[1:3] # => [2, 4] # Omit the beginning -li[2:] #=> [4, 3] +li[2:] # => [4, 3] # Omit the end -li[:3] #=> [1, 2, 4] +li[:3] # => [1, 2, 4] +# Select every second entry +li[::2] # =>[1, 4] +# Reverse a copy of the list +li[::-1] # => [3, 4, 2, 1] +# Use any combination of these to make advanced slices +# li[start:end:step] -# Remove arbitrary elements from a list with del -del li[2] # li is now [1, 2, 3] +# Remove arbitrary elements from a list with "del" +del li[2] # li is now [1, 2, 3] # You can add lists -li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li and other_li is left alone +li + other_li # => [1, 2, 3, 4, 5, 6] +# Note: values for li and for other_li are not modified. -# Concatenate lists with extend -li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] +# Concatenate lists with "extend()" +li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] -# Check for existence in a list with in -1 in li #=> True +# Check for existence in a list with "in" +1 in li # => True -# Examine the length with len -len(li) #=> 6 +# Examine the length with "len()" +len(li) # => 6 # Tuples are like lists but are immutable. tup = (1, 2, 3) -tup[0] #=> 1 +tup[0] # => 1 tup[0] = 3 # Raises a TypeError # You can do all those list thingies on tuples too -len(tup) #=> 3 -tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) -tup[:2] #=> (1, 2) -2 in tup #=> True +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True # You can unpack tuples (or lists) into variables a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3 @@ -199,60 +238,68 @@ empty_dict = {} filled_dict = {"one": 1, "two": 2, "three": 3} # Look up values with [] -filled_dict["one"] #=> 1 +filled_dict["one"] # => 1 -# Get all keys as a list -filled_dict.keys() #=> ["three", "two", "one"] +# Get all keys as a list with "keys()" +filled_dict.keys() # => ["three", "two", "one"] # Note - Dictionary key ordering is not guaranteed. # Your results might not match this exactly. -# Get all values as a list -filled_dict.values() #=> [3, 2, 1] +# Get all values as a list with "values()" +filled_dict.values() # => [3, 2, 1] # Note - Same as above regarding key ordering. -# Check for existence of keys in a dictionary with in -"one" in filled_dict #=> True -1 in filled_dict #=> False +# Check for existence of keys in a dictionary with "in" +"one" in filled_dict # => True +1 in filled_dict # => False - # Looking up a non-existing key is a KeyError -filled_dict["four"] # KeyError +# Looking up a non-existing key is a KeyError +filled_dict["four"] # KeyError -# Use get method to avoid the KeyError -filled_dict.get("one") #=> 1 -filled_dict.get("four") #=> None +# Use "get()" method to avoid the KeyError +filled_dict.get("one") # => 1 +filled_dict.get("four") # => None # The get method supports a default argument when the value is missing -filled_dict.get("one", 4) #=> 1 -filled_dict.get("four", 4) #=> 4 +filled_dict.get("one", 4) # => 1 +filled_dict.get("four", 4) # => 4 +# note that filled_dict.get("four") is still => None +# (get doesn't set the value in the dictionary) + +# set the value of a key with a syntax similar to lists +filled_dict["four"] = 4 # now, filled_dict["four"] => 4 -# Setdefault method is a safe way to add new key-value pair into dictionary -filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5 -filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5 +# "setdefault()" inserts into a dictionary only if the given key isn't present +filled_dict.setdefault("five", 5) # filled_dict["five"] is set to 5 +filled_dict.setdefault("five", 6) # filled_dict["five"] is still 5 -# Sets store ... well sets +# Sets store ... well sets (which are like lists but can contain no duplicates) empty_set = set() -# Initialize a set with a bunch of values -some_set = set([1,2,2,3,4]) # filled_set is now set([1, 2, 3, 4]) +# Initialize a "set()" with a bunch of values +some_set = set([1, 2, 2, 3, 4]) # some_set is now set([1, 2, 3, 4]) + +# order is not guaranteed, even though it may sometimes look sorted +another_set = set([4, 3, 2, 2, 1]) # another_set is now set([1, 2, 3, 4]) # Since Python 2.7, {} can be used to declare a set -filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} +filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4} # Add more items to a set -filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} +filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} # Do set intersection with & other_set = {3, 4, 5, 6} -filled_set & other_set #=> {3, 4, 5} +filled_set & other_set # => {3, 4, 5} # Do set union with | -filled_set | other_set #=> {1, 2, 3, 4, 5, 6} +filled_set | other_set # => {1, 2, 3, 4, 5, 6} # Do set difference with - -{1,2,3,4} - {2,3,5} #=> {1, 4} +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} # Check for existence in a set with in -2 in filled_set #=> True -10 in filled_set #=> False +2 in filled_set # => True +10 in filled_set # => False #################################################### @@ -263,7 +310,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6} some_var = 5 # Here is an if statement. Indentation is significant in python! -# prints "some var is smaller than 10" +# prints "some_var is smaller than 10" if some_var > 10: print "some_var is totally bigger than 10." elif some_var < 10: # This elif clause is optional. @@ -280,11 +327,11 @@ prints: mouse is a mammal """ for animal in ["dog", "cat", "mouse"]: - # You can use % to interpolate formatted strings - print "%s is a mammal" % animal - + # You can use {0} to interpolate formatted strings. (See above.) + print "{0} is a mammal".format(animal) + """ -`range(number)` returns a list of numbers +"range(number)" returns a list of numbers from zero to the given number prints: 0 @@ -296,6 +343,18 @@ for i in range(4): print i """ +"range(lower, upper)" returns a list of numbers +from the lower number to the upper number +prints: + 4 + 5 + 6 + 7 +""" +for i in range(4, 8): + print i + +""" While loops go until a condition is no longer met. prints: 0 @@ -312,42 +371,54 @@ while x < 4: # Works on Python 2.6 and up: try: - # Use raise to raise an error + # Use "raise" to raise an error raise IndexError("This is an index error") except IndexError as e: pass # Pass is just a no-op. Usually you would do recovery here. - +except (TypeError, NameError): + pass # Multiple exceptions can be handled together, if required. +else: # Optional clause to the try/except block. Must follow all except blocks + print "All good!" # Runs only if the code in try raises no exceptions +finally: # Execute under all circumstances + print "We can clean up resources here" + +# Instead of try/finally to cleanup resources you can use a with statement +with open("myfile.txt") as f: + for line in f: + print line #################################################### ## 4. Functions #################################################### -# Use def to create new functions +# Use "def" to create new functions def add(x, y): - print "x is %s and y is %s" % (x, y) + print "x is {0} and y is {1}".format(x, y) return x + y # Return values with a return statement # Calling functions with parameters -add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11 +add(5, 6) # => prints out "x is 5 and y is 6" and returns 11 # Another way to call functions is with keyword arguments add(y=6, x=5) # Keyword arguments can arrive in any order. + # You can define functions that take a variable number of -# positional arguments +# positional args, which will be interpreted as a tuple if you do not use the * def varargs(*args): return args -varargs(1, 2, 3) #=> (1,2,3) +varargs(1, 2, 3) # => (1, 2, 3) # You can define functions that take a variable number of -# keyword arguments, as well +# keyword args, as well, which will be interpreted as a dict if you do not use ** def keyword_args(**kwargs): return kwargs # Let's call it to see what happens -keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} +keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} + # You can do both at once, if you like def all_the_args(*args, **kwargs): @@ -359,13 +430,37 @@ all_the_args(1, 2, a=3, b=4) prints: {"a": 3, "b": 4} """ -# When calling functions, you can do the opposite of varargs/kwargs! -# Use * to expand tuples and use ** to expand kwargs. +# When calling functions, you can do the opposite of args/kwargs! +# Use * to expand positional args and use ** to expand keyword args. args = (1, 2, 3, 4) kwargs = {"a": 3, "b": 4} -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) +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) + +# you can pass args and kwargs along to other functions that take args/kwargs +# by expanding them with * and ** respectively +def pass_all_the_args(*args, **kwargs): + all_the_args(*args, **kwargs) + print varargs(*args) + print keyword_args(**kwargs) + +# Function Scope +x = 5 + +def setX(num): + # Local var x not the same as global variable x + x = num # => 43 + print x # => 43 + +def setGlobalX(num): + global x + print x # => 5 + x = num # global var x is now set to 6 + print x # => 6 + +setX(43) +setGlobalX(6) # Python has first class functions def create_adder(x): @@ -374,18 +469,19 @@ def create_adder(x): return adder add_10 = create_adder(10) -add_10(3) #=> 13 +add_10(3) # => 13 # There are also anonymous functions -(lambda x: x > 2)(3) #=> True +(lambda x: x > 2)(3) # => True # There are built-in higher order functions -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] +map(add_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] # We can use list comprehensions for nice maps and filters -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] -[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + #################################################### ## 5. Classes @@ -394,17 +490,20 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] # We subclass from object to get a class. class Human(object): - # A class attribute. It is shared by all instances of this class + # A class attribute. It is shared by all instances of this class species = "H. sapiens" - # Basic initializer + # Basic initializer, this is called when this class is instantiated. + # Note that the double leading and trailing underscores denote objects + # or attributes that are used by python but that live in user-controlled + # namespaces. You should not invent such names on your own. def __init__(self, name): # Assign the argument to the instance's name attribute self.name = name - # An instance method. All methods take self as the first argument + # An instance method. All methods take "self" as the first argument def say(self, msg): - return "%s: %s" % (self.name, msg) + return "{0}: {1}".format(self.name, msg) # A class method is shared among all instances # They are called with the calling class as the first argument @@ -423,18 +522,18 @@ i = Human(name="Ian") print i.say("hi") # prints out "Ian: hi" j = Human("Joel") -print j.say("hello") #prints out "Joel: hello" +print j.say("hello") # prints out "Joel: hello" # Call our class method -i.get_species() #=> "H. sapiens" +i.get_species() # => "H. sapiens" # Change the shared attribute Human.species = "H. neanderthalensis" -i.get_species() #=> "H. neanderthalensis" -j.get_species() #=> "H. neanderthalensis" +i.get_species() # => "H. neanderthalensis" +j.get_species() # => "H. neanderthalensis" # Call the static method -Human.grunt() #=> "*grunt*" +Human.grunt() # => "*grunt*" #################################################### @@ -443,12 +542,12 @@ Human.grunt() #=> "*grunt*" # You can import modules import math -print math.sqrt(16) #=> 4 +print math.sqrt(16) # => 4 # You can get specific functions from a module from math import ceil, floor -print ceil(3.7) #=> 4.0 -print floor(3.7) #=> 3.0 +print ceil(3.7) # => 4.0 +print floor(3.7) # => 3.0 # You can import all functions from a module. # Warning: this is not recommended @@ -456,10 +555,13 @@ from math import * # You can shorten module names import math as m -math.sqrt(16) == m.sqrt(16) #=> True +math.sqrt(16) == m.sqrt(16) # => True +# you can also test that the functions are equivalent +from math import sqrt +math.sqrt == m.sqrt == sqrt # => True # Python modules are just ordinary python files. You -# can write your own, and import them. The name of the +# can write your own, and import them. The name of the # module is the same as the name of the file. # You can find out which functions and attributes @@ -468,14 +570,77 @@ import math dir(math) +#################################################### +## 7. Advanced +#################################################### + +# Generators help you make lazy code +def double_numbers(iterable): + for i in iterable: + yield i + i + +# A generator creates values on the fly. +# Instead of generating and returning all values at once it creates one in each +# iteration. This means values bigger than 15 wont be processed in +# double_numbers. +# Note xrange is a generator that does the same thing range does. +# Creating a list 1-900000000 would take lot of time and space to be made. +# xrange creates an xrange generator object instead of creating the entire list +# like range does. +# We use a trailing underscore in variable names when we want to use a name that +# would normally collide with a python keyword +xrange_ = xrange(1, 900000000) + +# will double all numbers until a result >=30 found +for i in double_numbers(xrange_): + print i + if i >= 30: + break + + +# Decorators +# in this example beg wraps say +# Beg will call say. If say_please is True then it will change the returned +# message +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please + + +print say() # Can you buy me a beer? +print say(say_please=True) # Can you buy me a beer? Please! I am poor :( ``` -## Further Reading +## Ready For More? -Still up for more? Try: +### Free Online +* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) * [Dive Into Python](http://www.diveintopython.net/) * [The Official Docs](http://docs.python.org/2.6/) * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) * [Python Module of the Week](http://pymotw.com/2/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) +* [First Steps With Python](https://realpython.com/learn/python-first-steps/) + +### Dead Tree + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/python3.html.markdown b/python3.html.markdown new file mode 100644 index 00000000..acd6187c --- /dev/null +++ b/python3.html.markdown @@ -0,0 +1,722 @@ +--- +language: python3 +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 +--- + +Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular +languages in existence. I fell in love with Python for its syntactic clarity. It's basically +executable pseudocode. + +Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service] + +Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/python/) if you want to learn the old Python 2.7 + +```python + +# Single line comments start with a number symbol. + +""" Multiline strings can be written + using three "s, and are often used + as comments +""" + +#################################################### +## 1. Primitive Datatypes and Operators +#################################################### + +# You have numbers +3 # => 3 + +# Math is what you would expect +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 + +# Except division which returns floats, real numbers, by default +35 / 5 # => 7.0 + +# Result of integer division truncated down both for positive and negative. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # works on floats too +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# When you use a float, results are floats +3 * 2.0 # => 6.0 + +# Modulo operation +7 % 3 # => 1 + +# Exponentiation (x**y, x to the yth power) +2**4 # => 16 + +# Enforce precedence with parentheses +(1 + 3) * 2 # => 8 + +# Boolean values are primitives (Note: the capitalization) +True +False + +# negate with not +not True # => False +not False # => True + +# Boolean Operators +# Note "and" and "or" are case-sensitive +True and False #=> False +False or True #=> True + +# Note using Bool operators with ints +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Equality is == +1 == 1 # => True +2 == 1 # => False + +# Inequality is != +1 != 1 # => False +2 != 1 # => True + +# More comparisons +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Comparisons can be chained! +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.' + +# Strings can be added too! But try not to do this. +"Hello " + "world!" # => "Hello world!" +# Strings can be added without using '+' +"Hello " "world!" # => "Hello world!" + +# A string can be treated like a list of characters +"This is a string"[0] # => 'T' + +# .format can be used to format strings, like this: +"{} can be {}".format("strings", "interpolated") + +# You can repeat the formatting arguments to save some typing. +"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick") +#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick" + +# You can use keywords if you don't want to count. +"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna" + +# If your Python 3 code also needs to run on Python 2.5 and below, you can also +# still use the old style of formatting: +"%s can be %s the %s way" % ("strings", "interpolated", "old") + + +# None is an object +None # => None + +# Don't use the equality "==" symbol to compare objects to None +# Use "is" instead. This checks for equality of object identity. +"etc" is None # => False +None is None # => True + +# None, 0, and empty strings/lists/dicts all evaluate to False. +# All other values are True +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. Variables and Collections +#################################################### + +# 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 +some_var # => 5 + +# Accessing a previously unassigned variable is an exception. +# See Control Flow to learn more about exception handling. +some_unknown_var # Raises a NameError + +# Lists store sequences +li = [] +# You can start with a prefilled list +other_li = [4, 5, 6] + +# Add stuff to the end of a list with append +li.append(1) # li is now [1] +li.append(2) # li is now [1, 2] +li.append(4) # li is now [1, 2, 4] +li.append(3) # li is now [1, 2, 4, 3] +# Remove from the end with pop +li.pop() # => 3 and li is now [1, 2, 4] +# Let's put it back +li.append(3) # li is now [1, 2, 4, 3] again. + +# Access a list like you would any array +li[0] # => 1 +# Look at the last element +li[-1] # => 3 + +# Looking out of bounds is an IndexError +li[4] # Raises an IndexError + +# You can look at ranges with slice syntax. +# (It's a closed/open range for you mathy types.) +li[1:3] # => [2, 4] +# Omit the beginning +li[2:] # => [4, 3] +# Omit the end +li[:3] # => [1, 2, 4] +# Select every second entry +li[::2] # =>[1, 4] +# Return a reversed copy of the list +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] + +# You can add lists +# Note: values for li and for other_li are not modified. +li + other_li # => [1, 2, 3, 4, 5, 6] + +# Concatenate lists with "extend()" +li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] + +# Check for existence in a list with "in" +1 in li # => True + +# Examine the length with "len()" +len(li) # => 6 + + +# Tuples are like lists but are immutable. +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)) # => <class 'int'> +type((1,)) # => <class 'tuple'> +type(()) # => <class 'tuple'> + +# You can do most of the list operations on tuples too +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# You can unpack tuples (or lists) into variables +a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3 +# Tuples are created by default if you leave out the parentheses +d, e, f = 4, 5, 6 +# Now look how easy it is to swap two values +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionaries store mappings +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 + +# Get all keys as an iterable with "keys()". We need to wrap the call in list() +# to turn it into a list. We'll talk about those later. Note - Dictionary key +# ordering is not guaranteed. Your results might not match this exactly. +list(filled_dict.keys()) # => ["three", "two", "one"] + + +# Get all values as an iterable with "values()". Once again we need to wrap it +# in list() to get it out of the iterable. Note - Same as above regarding key +# ordering. +list(filled_dict.values()) # => [3, 2, 1] + + +# Check for existence of keys in a dictionary with "in" +"one" in filled_dict # => True +1 in filled_dict # => False + +# Looking up a non-existing key is a KeyError +filled_dict["four"] # KeyError + +# Use "get()" method to avoid the KeyError +filled_dict.get("one") # => 1 +filled_dict.get("four") # => None +# The get method supports a default argument when the value is missing +filled_dict.get("one", 4) # => 1 +filled_dict.get("four", 4) # => 4 + +# "setdefault()" inserts into a dictionary only if the given key isn't present +filled_dict.setdefault("five", 5) # filled_dict["five"] is set to 5 +filled_dict.setdefault("five", 6) # filled_dict["five"] is still 5 + +# Adding to a dictionary +filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} +#filled_dict["four"] = 4 #another way to add to dict + +# Remove keys from a dictionary with del +del filled_dict["one"] # Removes the key "one" from filled dict + + +# Sets store ... well sets +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 + +# Add one more item to the set +filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} + +# Do set intersection with & +other_set = {3, 4, 5, 6} +filled_set & other_set # => {3, 4, 5} + +# Do set union with | +filled_set | other_set # => {1, 2, 3, 4, 5, 6} + +# Do set difference with - +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Check for existence in a set with in +2 in filled_set # => True +10 in filled_set # => False + + + +#################################################### +## 3. Control Flow and Iterables +#################################################### + +# Let's just make a variable +some_var = 5 + +# Here is an if statement. Indentation is significant in python! +# prints "some_var is smaller than 10" +if some_var > 10: + print("some_var is totally bigger than 10.") +elif some_var < 10: # This elif clause is optional. + print("some_var is smaller than 10.") +else: # This is optional too. + print("some_var is indeed 10.") + + +""" +For loops iterate over lists +prints: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + # You can use format() to interpolate formatted strings + print("{} is a mammal".format(animal)) + +""" +"range(number)" returns an iterable of numbers +from zero to the given number +prints: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +"range(lower, upper)" returns an iterable of numbers +from the lower number to the upper number +prints: + 4 + 5 + 6 + 7 +""" +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 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Shorthand for x = x + 1 + +# Handle exceptions with a try/except block +try: + # Use "raise" to raise an error + raise IndexError("This is an index error") +except IndexError as e: + pass # Pass is just a no-op. Usually you would do recovery here. +except (TypeError, NameError): + pass # Multiple exceptions can be handled together, if required. +else: # Optional clause to the try/except block. Must follow all except blocks + print("All good!") # Runs only if the code in try raises no exceptions +finally: # Execute under all circumstances + print("We can clean up resources here") + +# Instead of try/finally to cleanup resources you can use a with statement +with open("myfile.txt") as f: + for line in f: + print(line) + +# Python offers a fundamental abstraction called the Iterable. +# An iterable is an object that can be treated as a sequence. +# The object returned the range function, is an iterable. + +filled_dict = {"one": 1, "two": 2, "three": 3} +our_iterable = filled_dict.keys() +print(our_iterable) #=> range(1,10). This is an object that implements our Iterable interface + +# We can loop over it. +for i in our_iterable: + print(i) # Prints one, two, three + +# However we cannot address elements by index. +our_iterable[1] # Raises a TypeError + +# An iterable is an object that knows how to create an iterator. +our_iterator = iter(our_iterable) + +# Our iterator is an object that can remember the state as we traverse through it. +# We get the next object with "next()". +next(our_iterator) #=> "one" + +# It maintains state as we iterate. +next(our_iterator) #=> "two" +next(our_iterator) #=> "three" + +# After the iterator has returned all of its data, it gives you a StopIterator Exception +next(our_iterator) # Raises StopIteration + +# You can grab all the elements of an iterator by calling list() on it. +list(filled_dict.keys()) #=> Returns ["one", "two", "three"] + + +#################################################### +## 4. Functions +#################################################### + +# Use "def" to create new functions +def add(x, y): + print("x is {} and y is {}".format(x, y)) + return x + y # Return values with a return statement + +# Calling functions with parameters +add(5, 6) # => prints out "x is 5 and y is 6" and returns 11 + +# Another way to call functions is with keyword arguments +add(y=6, x=5) # Keyword arguments can arrive in any order. + +# You can define functions that take a variable number of +# positional arguments +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1, 2, 3) + +# You can define functions that take a variable number of +# keyword arguments, as well +def keyword_args(**kwargs): + return kwargs + +# Let's call it to see what happens +keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} + + +# You can do both at once, if you like +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) prints: + (1, 2) + {"a": 3, "b": 4} +""" + +# When calling functions, you can do the opposite of args/kwargs! +# Use * to expand tuples and use ** to expand kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +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 + +def setX(num): + # Local var x not the same as global variable x + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # global var x is now set to 6 + print (x) # => 6 + +setX(43) +setGlobalX(6) + + +# Python has first class functions +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) # => 13 + +# There are also anonymous functions +(lambda x: x > 2)(3) # => True + +# TODO - Fix for iterables +# There are built-in higher order functions +map(add_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# We can use list comprehensions for nice maps and filters +# List comprehension stores the output as a list which can itself be a nested list +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +#################################################### +## 5. Classes +#################################################### + + +# We subclass from object to get a class. +class Human(object): + + # A class attribute. It is shared by all instances of this class + species = "H. sapiens" + + # Basic initializer, this is called when this class is instantiated. + # Note that the double leading and trailing underscores denote objects + # or attributes that are used by python but that live in user-controlled + # namespaces. Methods(or objects or attributes) like: __init__, __str__, + # __repr__ etc. are called magic methods (or sometimes called dunder methods) + # You should not invent such names on your own. + def __init__(self, name): + # Assign the argument to the instance's name attribute + self.name = name + + # An instance method. All methods take "self" as the first argument + def say(self, msg): + return "{name}: {message}".format(name=self.name, message=msg) + + # A class method is shared among all instances + # They are called with the calling class as the first argument + @classmethod + def get_species(cls): + return cls.species + + # A static method is called without a class or instance reference + @staticmethod + def grunt(): + return "*grunt*" + + +# Instantiate a class +i = Human(name="Ian") +print(i.say("hi")) # prints out "Ian: hi" + +j = Human("Joel") +print(j.say("hello")) # prints out "Joel: hello" + +# Call our class method +i.get_species() # => "H. sapiens" + +# Change the shared attribute +Human.species = "H. neanderthalensis" +i.get_species() # => "H. neanderthalensis" +j.get_species() # => "H. neanderthalensis" + +# Call the static method +Human.grunt() # => "*grunt*" + + +#################################################### +## 6. Modules +#################################################### + +# You can import modules +import math +print(math.sqrt(16)) # => 4 + +# You can get specific functions from a module +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# You can import all functions from a module. +# Warning: this is not recommended +from math import * + +# You can shorten module names +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Python modules are just ordinary python files. You +# can write your own, and import them. The name of the +# module is the same as the name of the file. + +# You can find out which functions and attributes +# defines a module. +import math +dir(math) + + +#################################################### +## 7. Advanced +#################################################### + +# Generators help you make lazy code +def double_numbers(iterable): + for i in iterable: + yield i + i + +# A generator creates values on the fly. +# Instead of generating and returning all values at once it creates one in each +# iteration. This means values bigger than 15 wont be processed in +# double_numbers. +# Note range is a generator too. Creating a list 1-900000000 would take lot of +# time to be made +# We use a trailing underscore in variable names when we want to use a name that +# would normally collide with a python keyword +range_ = range(1, 900000000) +# will double all numbers until a result >=30 found +for i in double_numbers(range_): + print(i) + if i >= 30: + break + + +# Decorators +# in this example beg wraps say +# Beg will call say. If say_please is True then it will change the returned +# message +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please + + +print(say()) # Can you buy me a beer? +print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( +``` + +## Ready For More? + +### Free Online + +* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) +* [Python Course](http://www.python-course.eu/index.php) +* [First Steps With Python](https://realpython.com/learn/python-first-steps/) + +### Dead Tree + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/r.html.markdown b/r.html.markdown index 0240e8fb..93751df5 100644 --- a/r.html.markdown +++ b/r.html.markdown @@ -2,165 +2,384 @@ language: R contributors: - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] filename: learnr.r --- -R is a statistical computing language. It has lots of good built-in functions for uploading and cleaning data sets, running common statistical tests, and making graphs. You can also easily compile it within a LaTeX document. +R is a statistical computing language. It has lots of libraries for uploading and cleaning data sets, running statistical procedures, and making graphs. You can also run `R` commands within a LaTeX document. -```python +```r -# Comments start with hashtags. +# Comments start with number symbols. -# You can't make a multi-line comment per se, +# You can't make multi-line comments, # but you can stack multiple comments like so. -# Hit COMMAND-ENTER to execute a line +# in Windows or Mac, hit COMMAND-ENTER to execute a line -######################### -# The absolute basics -######################### -# NUMBERS -# We've got doubles! Behold the "numeric" class -5 # => [1] 5 -class(5) # => [1] "numeric" -# We've also got integers! They look suspiciously similar, -# but indeed are different -5L # => [1] 5 -class(5L) # => [1] "integer" -# Try ?class for more information on the class() function -# In fact, you can look up the documentation on just about anything with ? +############################################################################# +# Stuff you can do without understanding anything about programming +############################################################################# -# All the normal operations! -10 + 66 # => [1] 76 -53.2 - 4 # => [1] 49.2 -2 * 2.0 # => [1] 4 -3L / 4 # => [1] 0.75 -3 %% 2 # => [1] 1 +# In this section, we show off some of the cool stuff you can do in +# R without understanding anything about programming. Do not worry +# about understanding everything the code does. Just enjoy! -# Finally, we've got not-a-numbers! They're numerics too -class(NaN) # => [1] "numeric" +data() # browse pre-loaded data sets +data(rivers) # get this one: "Lengths of Major North American Rivers" +ls() # notice that "rivers" now appears in the workspace +head(rivers) # peek at the data set +# 735 320 325 392 524 450 -# CHARACTERS +length(rivers) # how many rivers were measured? +# 141 +summary(rivers) # what are some summary statistics? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + +# make a stem-and-leaf plot (a histogram-like data visualization) +stem(rivers) + +# The decimal point is 2 digit(s) to the right of the | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + +stem(log(rivers)) # Notice that the data are neither normal nor log-normal! +# Take that, Bell curve fundamentalists. + +# The decimal point is 1 digit(s) to the left of the | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# make a histogram: +hist(rivers, col="#333333", border="white", breaks=25) # play around with these parameters +hist(log(rivers), col="#333333", border="white", breaks=25) # you'll do more plotting later + +# Here's another neat data set that comes pre-loaded. R has tons of these. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + +# Rather than leaving the default ordering (by year), +# we could also sort to see what's typical: +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) +# +# The decimal point is at the | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + +# Roll a die a few times +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# Your numbers will differ from mine unless we set the same random.seed(31337) + +# Draw from a standard Gaussian 9 times +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +################################################## +# Data types and basic arithmetic +################################################## + +# Now for the programming-oriented part of the tutorial. +# In this section you will meet the important data types of R: +# integers, numerics, characters, logicals, and factors. +# There are others, but these are the bare minimum you need to +# get started. + +# INTEGERS +# Long-storage integers are written with L +5L # 5 +class(5L) # "integer" +# (Try ?class for more information on the class() function.) +# In R, every single value, like 5L, is considered a vector of length 1 +length(5L) # 1 +# You can have an integer vector with length > 1 too: +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + +# NUMERICS +# A "numeric" is a double-precision floating-point number +5 # 5 +class(5) # "numeric" +# Again, everything in R is a vector; +# you can make a numeric vector with more than one element +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# You can use scientific notation too +5e4 # 50000 +6.02e23 # Avogadro's number +1.6e-35 # Planck length +# You can also have infinitely large or small numbers +class(Inf) # "numeric" +class(-Inf) # "numeric" +# You might use "Inf", for example, in integrate(dnorm, 3, Inf); +# this obviates Z-score tables. + +# BASIC ARITHMETIC +# You can do arithmetic with numbers +# Doing arithmetic on a mix of integers and numerics gives you another numeric +10L + 66L # 76 # integer plus integer gives integer +53.2 - 4 # 49.2 # numeric minus numeric gives numeric +2.0 * 2L # 4 # numeric times integer gives numeric +3L / 4 # 0.75 # integer over numeric gives numeric +3 %% 2 # 1 # the remainder of two numerics is another numeric +# Illegal arithmetic yeilds you a "not-a-number": +0 / 0 # NaN +class(NaN) # "numeric" +# You can do arithmetic on two vectors with length greater than 1, +# so long as the larger vector's length is an integer multiple of the smaller +c(1,2,3) + c(1,2,3) # 2 4 6 -# We've (sort of) got strings! Behold the "character" class -"plugh" # => [1] "plugh" -class("plugh") # "character" +# CHARACTERS # There's no difference between strings and characters in R +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# Those were both character vectors of length 1 +# Here is a longer one: +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# => +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# You can do regex operations on character vectors: +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# R has several built-in character vectors: +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" # LOGICALS - -# We've got booleans! Behold the "logical" class -class(TRUE) # => [1] "logical" -class(FALSE) # => [1] "logical" -# Behavior is normal -TRUE == TRUE # => [1] TRUE -TRUE == FALSE # => [1] FALSE -FALSE != FALSE # => [1] FALSE -FALSE != TRUE # => [1] TRUE +# In R, a "logical" is a boolean +class(TRUE) # "logical" +class(FALSE) # "logical" +# Their behavior is normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE # Missing data (NA) is logical, too -class(NA) # => [1] "logical" +class(NA) # "logical" +# Use | and & for logic operations. +# OR +TRUE | FALSE # TRUE +# AND +TRUE & FALSE # FALSE +# You can test if x is TRUE +isTRUE(TRUE) # TRUE +# Here we get a logical vector with many elements: +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE # FACTORS - # The factor class is for categorical data -# It has an attribute called levels that describes all the possible categories -factor("dog") +# Factors can be ordered (like childrens' grade levels) or unordered (like gender) +factor(c("female", "female", "male", NA, "female")) +# female female male <NA> female +# Levels: female male +# The "levels" are the values the categorical data can take +# Note that missing data does not enter the levels +levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" +# If a factor vector has length 1, its levels will have length 1, too +length(factor("male")) # 1 +length(levels(factor("male"))) # 1 +# Factors are commonly seen in data frames, a data structure we will cover later +data(infert) # "Infertility after Spontaneous and Induced Abortion" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + +# NULL +# "NULL" is a weird one; use it to "blank out" a vector +class(NULL) # NULL +parakeet = c("beak", "feathers", "wings", "eyes") +parakeet +# => +# [1] "beak" "feathers" "wings" "eyes" +parakeet <- NULL +parakeet # => -# [1] dog -# Levels: dog -# (This will make more sense once we start talking about vectors) +# NULL + +# TYPE COERCION +# Type-coercion is when you force a value to take on a different type +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# If you put elements of different types into a vector, weird coercions happen: +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Warning message: +# NAs introduced by coercion -# VARIABLES +# Also note: those were just the basic data types +# There are many more data types, such as for dates, time series, etc. -# Lots of way to assign stuff + + +################################################## +# Variables, loops, if/else +################################################## + +# A variable is like a box you store a value in for later use. +# We call this "assigning" the value to the variable. +# Having variables lets us write loops, functions, and if/else statements + +# VARIABLES +# Lots of way to assign stuff: x = 5 # this is possible y <- "1" # this is preferred TRUE -> z # this works but is weird -# We can use coerce variables to different classes -as.numeric(y) # => [1] 1 -as.character(x) # => [1] "5" - # LOOPS - # We've got for loops for (i in 1:4) { print(i) } - # We've got while loops a <- 10 while (a > 4) { cat(a, "...", sep = "") a <- a - 1 } - # Keep in mind that for and while loops run slowly in R # Operations on entire vectors (i.e. a whole row, a whole column) # or apply()-type functions (we'll discuss later) are preferred # IF/ELSE - # Again, pretty standard if (4 > 3) { - print("Huzzah! It worked!") + print("4 is greater than 3") } else { - print("Noooo! This is blatantly illogical!") + print("4 is not greater than 3") } # => -# [1] "Huzzah! It worked!" +# [1] "4 is greater than 3" # FUNCTIONS - # Defined like so: -myFunc <- function(x) { - x <- x * 4 - x <- x - 1 +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) #add in a bit of (controlled) noise return(x) } - # Called like any other R function: -myFunc(5) # => [1] 19 +jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 + -######################### -# Fun with data: vectors, matrices, data frames, and arrays -######################### + +########################################################################### +# Data structures: Vectors, matrices, data frames, and arrays +########################################################################### # ONE-DIMENSIONAL -# You can vectorize anything, so long as all components have the same type +# Let's start from the very beginning, and with something you already know: vectors. vec <- c(8, 9, 10, 11) -vec # => [1] 8 9 10 11 -# The class of a vector is the class of its components -class(vec) # => [1] "numeric" -# If you vectorize items of different classes, weird coercions happen -c(TRUE, 4) # => [1] 1 4 -c("dog", TRUE, 4) # => [1] "dog" "TRUE" "4" - -# We ask for specific components like so (R starts counting from 1) -vec[1] # => [1] 8 +vec # 8 9 10 11 +# We ask for specific elements by subsetting with square brackets +# (Note that R starts counting from 1) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 # We can also search for the indices of specific components, -which(vec %% 2 == 0) # => [1] 1 3 -# or grab just the first or last entry in the vector -head(vec, 1) # => [1] 8 -tail(vec, 1) # => [1] 11 +which(vec %% 2 == 0) # 1 3 +# grab just the first or last few entries in the vector, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# or figure out if a certain value is in the vector +any(vec == 10) # TRUE # If an index "goes over" you'll get NA: -vec[6] # => [1] NA +vec[6] # NA # You can find the length of your vector with length() -length(vec) # => [1] 4 - +length(vec) # 4 # You can perform operations on entire vectors or subsets of vectors -vec * 4 # => [1] 16 20 24 28 -vec[2:3] * 5 # => [1] 25 30 -# and there are many built-in functions to summarize vectors -mean(vec) # => [1] 9.5 -var(vec) # => [1] 1.666667 -sd(vec) # => [1] 1.290994 -max(vec) # => [1] 11 -min(vec) # => [1] 8 -sum(vec) # => [1] 38 +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# and R has many built-in functions to summarize vectors +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Some more nice built-ins: +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 # TWO-DIMENSIONAL (ALL ONE CLASS) @@ -175,11 +394,12 @@ mat # Unlike a vector, the class of a matrix is "matrix", no matter what's in it class(mat) # => "matrix" # Ask for the first row -mat[1,] # => [1] 1 4 +mat[1,] # 1 4 # Perform operation on the first column -3 * mat[,1] # => [1] 3 6 9 +3 * mat[,1] # 3 6 9 # Ask for a specific cell -mat[3,2] # => [1] 6 +mat[3,2] # 6 + # Transpose the whole matrix t(mat) # => @@ -187,16 +407,24 @@ t(mat) # [1,] 1 2 3 # [2,] 4 5 6 +# Matrix multiplication +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + # cbind() sticks vectors together column-wise to make a matrix mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) mat2 # => -# [,1] [,2] -# [1,] "1" "dog" -# [2,] "2" "cat" -# [3,] "3" "bird" +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" # [4,] "4" "dog" -class(mat2) # => [1] matrix +class(mat2) # matrix # Again, note what happened! # Because matrices must contain entries all of the same class, # everything got converted to the character class @@ -209,33 +437,138 @@ mat3 # [,1] [,2] [,3] [,4] # [1,] 1 2 4 5 # [2,] 6 7 0 4 -# Aah, everything of the same class. No coercions. Much better. +# Ah, everything of the same class. No coercions. Much better. # TWO-DIMENSIONAL (DIFFERENT CLASSES) -# For columns of different classes, use the data frame -dat <- data.frame(c(5,2,1,4), c("dog", "cat", "bird", "dog")) -names(dat) <- c("number", "species") # name the columns -class(dat) # => [1] "data.frame" -dat +# For columns of different types, use a data frame +# This data structure is so useful for statistical programming, +# a version of it was added to Python in the package "pandas". + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") # name the columns +class(students) # "data.frame" +students # => -# number species -# 1 5 dog -# 2 2 cat -# 3 1 bird -# 4 4 dog -class(dat$number) # => [1] "numeric" -class(dat[,2]) # => [1] "factor" +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# find the dimensions +nrow(students) # 6 +ncol(students) # 3 +dim(students) # 6 3 # The data.frame() function converts character vectors to factor vectors +# by default; turn this off by setting stringsAsFactors = FALSE when +# you create the data.frame +?data.frame # There are many twisty ways to subset data frames, all subtly unalike -dat$number # => [1] 5 2 1 4 -dat[,1] # => [1] 5 2 1 4 -dat[,"number"] # => [1] 5 2 1 4 +students$year # 3 2 2 1 0 -1 +students[,2] # 3 2 2 1 0 -1 +students[,"year"] # 3 2 2 1 0 -1 + +# An augmented version of the data.frame structure is the data.table +# If you're working with huge or panel data, or need to merge a few data +# sets, data.table can be a good choice. Here's a whirlwind tour: +install.packages("data.table") # download the package from CRAN +require(data.table) # load it +students <- as.data.table(students) +students # note the slightly different print-out +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # get rows with name == "Ginny" +# => +# name year house +# 1: Ginny -1 G +students[year==2] # get rows with year == 2 +# => +# name year house +# 1: Fred 2 G +# 2: George 2 G +# data.table makes merging two data sets easy +# let's make another data.table to merge with students +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # merge the two data sets by matching "house" +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# data.table makes summary tables easy +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# To drop a column from a data.frame or data.table, +# assign it the NULL value +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Drop a row by subsetting +# Using data.table: +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# Using data.frame: +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 -# MULTI-DIMENSIONAL (ALL OF ONE CLASS) +# MULTI-DIMENSIONAL (ALL ELEMENTS OF ONE TYPE) # Arrays creates n-dimensional tables +# All elements must be of the same type # You can make a two-dimensional table (sort of like a matrix) array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) # => @@ -247,15 +580,17 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) # => # , , 1 # -# [,1] [,2] -# [1,] 1 4 -# [2,] 2 5 +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 # # , , 2 # # [,1] [,2] -# [1,] 8 1 -# [2,] 9 2 +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 # LISTS (MULTI-DIMENSIONAL, POSSIBLY RAGGED, OF DIFFERENT TYPES) @@ -263,15 +598,23 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) list1 <- list(time = 1:40) list1$price = c(rnorm(40,.5*list1$time,4)) # random list1 - # You can get items in the list like so -list1$time -# You can subset list items like vectors +list1$time # one way +list1[["time"]] # another way +list1[[1]] # yet another way +# => +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# You can subset list items like any other vector list1$price[4] -######################### +# Lists are not the most efficient data structure to work with in R; +# unless you have a very good reason, you should stick to data.frames +# Lists are often returned by functions that perform linear regressions + +################################################## # The apply() family of functions -######################### +################################################## # Remember mat? mat @@ -284,7 +627,7 @@ mat # over rows (MAR = 1) or columns (MAR = 2) # That is, R does FUN to each row (or column) of X, much faster than a # for or while loop would do -apply(mat, MAR = 2, myFunc) +apply(mat, MAR = 2, jiggle) # => # [,1] [,2] # [1,] 3 15 @@ -295,16 +638,18 @@ apply(mat, MAR = 2, myFunc) # Don't feel too intimidated; everyone agrees they are rather confusing # The plyr package aims to replace (and improve upon!) the *apply() family. - install.packages("plyr") require(plyr) ?plyr + + ######################### # Loading data ######################### # "pets.csv" is a file on the internet +# (but it could just as easily be be a file on your own computer) pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") pets head(pets, 2) # first two rows @@ -316,10 +661,13 @@ write.csv(pets, "pets2.csv") # to make a new .csv file # Try ?read.csv and ?write.csv for more information + + ######################### # Plots ######################### +# BUILT-IN PLOTTING FUNCTIONS # Scatterplots! plot(list1$time, list1$price, main = "fake data") # Regressions! @@ -329,18 +677,25 @@ linearModel # outputs result of regression abline(linearModel, col = "red") # Get a variety of nice diagnostics plot(linearModel) - # Histograms! hist(rpois(n = 10000, lambda = 5), col = "thistle") - # Barplots! barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) +# GGPLOT2 +# But these are not even the prettiest of R's plots # Try the ggplot2 package for more and better graphics - install.packages("ggplot2") require(ggplot2) ?ggplot2 +pp <- ggplot(students, aes(x=house)) +pp + geom_histogram() +ll <- as.data.table(list1) +pp <- ggplot(ll, aes(x=time,price)) +pp + geom_point() +# ggplot2 has excellent documentation (available http://docs.ggplot2.org/current/) + + ``` diff --git a/racket.html.markdown b/racket.html.markdown index adacd91d..0fe3f030 100644 --- a/racket.html.markdown +++ b/racket.html.markdown @@ -6,6 +6,8 @@ contributors: - ["th3rac25", "https://github.com/voila"] - ["Eli Barzilay", "https://github.com/elibarzilay"] - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"] + - ["Duong H. Nguyen", "https://github.com/cmpitg"] + - ["Keyan Zhang", "https://github.com/keyanzhang"] --- Racket is a general purpose, multi-paradigm programming language in the Lisp/Scheme family. @@ -195,7 +197,7 @@ my-pet ; => #<dog> (hash-ref m 'd 0) ; => 0 ;; Use `hash-set' to extend an immutable hash table -;; (Returns the extended hash instdead of mutating it) +;; (Returns the extended hash instead of mutating it) (define m2 (hash-set m 'd 4)) m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3)) @@ -223,7 +225,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' (define hello-world (lambda () "Hello World")) (hello-world) ; => "Hello World" -;; You can shorten this using the function definition syntatcic sugae: +;; You can shorten this using the function definition syntactic sugar: (define (hello-world2) "Hello World") ;; The () in the above is the list of arguments for the function @@ -281,16 +283,49 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' ;; for numbers use `=' (= 3 3.0) ; => #t -(= 2 1) ; => #f +(= 2 1) ; => #f + +;; `eq?' returns #t if 2 arguments refer to the same object (in memory), +;; #f otherwise. +;; In other words, it's a simple pointer comparison. +(eq? '() '()) ; => #t, since there exists only one empty list in memory +(let ([x '()] [y '()]) + (eq? x y)) ; => #t, same as above -;; for object identity use `eq?' -(eq? 3 3) ; => #t -(eq? 3 3.0) ; => #f (eq? (list 3) (list 3)) ; => #f +(let ([x (list 3)] [y (list 3)]) + (eq? x y)) ; => #f — not the same list in memory! + +(let* ([x (list 3)] [y x]) + (eq? x y)) ; => #t, since x and y now point to the same stuff + +(eq? 'yes 'yes) ; => #t +(eq? 'yes 'no) ; => #f + +(eq? 3 3) ; => #t — be careful here + ; It’s better to use `=' for number comparisons. +(eq? 3 3.0) ; => #f + +(eq? (expt 2 100) (expt 2 100)) ; => #f +(eq? (integer->char 955) (integer->char 955)) ; => #f -;; for collections use `equal?' -(equal? (list 'a 'b) (list 'a 'b)) ; => #t -(equal? (list 'a 'b) (list 'b 'a)) ; => #f +(eq? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f + +;; `eqv?' supports the comparison of number and character datatypes. +;; for other datatypes, `eqv?' and `eq?' return the same result. +(eqv? 3 3.0) ; => #f +(eqv? (expt 2 100) (expt 2 100)) ; => #t +(eqv? (integer->char 955) (integer->char 955)) ; => #t + +(eqv? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f + +;; `equal?' supports the comparison of the following datatypes: +;; strings, byte strings, pairs, mutable pairs, vectors, boxes, +;; hash tables, and inspectable structures. +;; for other datatypes, `equal?' and `eqv?' return the same result. +(equal? 3 3.0) ; => #f +(equal? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #t +(equal? (list 3) (list 3)) ; => #t ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; 5. Control Flow @@ -495,7 +530,7 @@ vec ; => #(1 2 3 4) ;; 8. Classes and Objects ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Create a class fish% (-% is idomatic for class bindings) +;; Create a class fish% (-% is idiomatic for class bindings) (define fish% (class object% (init size) ; initialization argument @@ -551,7 +586,7 @@ vec ; => #(1 2 3 4) (set! i (add1 i)))) ;; Macros are hygienic, you cannot clobber existing variables! -(define-syntax-rule (swap! x y) ; -! is idomatic for mutation +(define-syntax-rule (swap! x y) ; -! is idiomatic for mutation (let ([tmp x]) (set! x y) (set! y tmp))) @@ -600,6 +635,45 @@ vec ; => #(1 2 3 4) ;; expected: positive? ;; given: -5 ;; more details.... + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 11. Input & output +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Racket has this concept of "port", which is very similar to file +;; descriptors in other languages + +;; Open "/tmp/tmp.txt" and write "Hello World" +;; This would trigger an error if the file's already existed +(define out-port (open-output-file "/tmp/tmp.txt")) +(displayln "Hello World" out-port) +(close-output-port out-port) + +;; Append to "/tmp/tmp.txt" +(define out-port (open-output-file "/tmp/tmp.txt" + #:exists 'append)) +(displayln "Hola mundo" out-port) +(close-output-port out-port) + +;; Read from the file again +(define in-port (open-input-file "/tmp/tmp.txt")) +(displayln (read-line in-port)) +; => "Hello World" +(displayln (read-line in-port)) +; => "Hola mundo" +(close-input-port in-port) + +;; Alternatively, with call-with-output-file you don't need to explicitly +;; close the file +(call-with-output-file "/tmp/tmp.txt" + #:exists 'update ; Rewrite the content + (λ (out-port) + (displayln "World Hello!" out-port))) + +;; And call-with-input-file does the same thing for input +(call-with-input-file "/tmp/tmp.txt" + (λ (in-port) + (displayln (read-line in-port)))) ``` ## Further Reading diff --git a/red.html.markdown b/red.html.markdown new file mode 100644 index 00000000..05da3c3f --- /dev/null +++ b/red.html.markdown @@ -0,0 +1,221 @@ +--- +name: Red +category: language +language: Red +filename: learnred.red +contributors: + - ["Arnold van Hofwegen", "https://github.com/iArnold"] +--- + + +Red was created out of the need to get work done, and the tool the author wanted to use, the language of REBOL, had a couple of drawbacks. +It was not Open Sourced at that time and it is an interpreted language, what means that it is on average slow compared to a compiled language. + +Red, together with its C-level dialect Red/System, provides a language that covers the entire programming space you ever need to program something in. +Red is a language heavily based on the language of REBOL. Where Red itself reproduces the flexibility of the REBOL language, the underlying language Red will be built upon, +Red/System, covers the more basic needs of programming like C can, being closer to the metal. + +Red will be the world's first Full Stack Programming Language. This means that it will be an effective tool to do (almost) any programming task on every level +from the metal to the meta without the aid of other stack tools. +Furthermore Red will be able to cross-compile Red source code without using any GCC like toolchain +from any platform to any other platform. And it will do this all from a binary executable that is supposed to stay under 1 MB. + +Ready to learn your first Red? + +``` +All text before the header will be treated as comment, as long as you avoid using the +word "red" starting with a capital "R" in this pre-header text. This is a temporary +shortcoming of the used lexer but most of the time you start your script or program +with the header itself. +The header of a red script is the capitalized word "red" followed by a +whitespace character followed by a block of square brackets []. +The block of brackets can be filled with useful information about this script or +program: the author's name, the filename, the version, the license, a summary of +what the program does or any other files it needs. +The red/System header is just like the red header, only saying "red/System" and +not "red". + +Red [] + +;this is a commented line + +print "Hello Red World" ; this is another comment + +comment { + This is a multiline comment. + You just saw the Red version of the "Hello World" program. +} + +; Your program's entry point is the first executable code that is found +; no need to restrict this to a 'main' function. + +; Valid variable names start with a letter and can contain numbers, +; variables containing only capital A thru F and numbers and ending with 'h' are +; forbidden, because that is how hexadecimal numbers are expressed in Red and +; Red/System. + +; assign a value to a variable using a colon ":" +my-name: "Red" +reason-for-using-the-colon: {Assigning values using the colon makes + the equality sign "=" exclusively usable for comparisons purposes, + exactly what "=" was intended for in the first place! + Remember this y = x + 1 and x = 1 => y = 2 stuff from school? +} +is-this-name-valid?: true + +; print output using print, or prin for printing without a newline or linefeed at the +; end of the printed text. + +prin " My name is " print my-name +My name is Red + +print ["My name is " my-name lf] +My name is Red + +; In case you haven't already noticed: statements do NOT end with a semicolon ;-) + +; +; Datatypes +; +; If you know Rebol, you probably have noticed it has lots of datatypes. Red +; does not have yet all those types, but as Red want to be close to Rebol it +; will have a lot of datatypes. +; You can recognize types by the exclamation sign at the end. But beware +; names ending with an exclamation sign are allowed. +; Some of the available types are integer! string! block! + +; Declaring variables before using them? +; Red knows by itself what variable is best to use for the data you want to use it +; for. +; A variable declaration is not always necessary. +; It is considered good coding practise to declare your variables, +; but it is not forced upon you by Red. +; You can declare a variable and specify its type. a variable's type determines its +; size in bytes. + +; Variables of integer! type are usually 4 bytes or 32 bits +my-integer: 0 +; Red's integers are signed. No support for unsigned atm but that will come. + +; To find out the type of variable use type? +type? my-integer +integer! + +; A variable can be initialized using another variable that gets initialized +; at the same time. +i2: 1 + i1: 1 + +; Arithmetic is straightforward +i1 + i2 ; result 3 +i2 - i1 ; result 1 +i2 * i1 ; result 2 +i1 / i2 ; result 0 (0.5, but truncated towards 0) + +; Comparison operators are probably familiar, and unlike in other languages you +; only need a single '=' sign for comparison. +; There is a boolean like type in Red. It has values true and false, but also the +; values on/off or yes/no can be used + +3 = 2 ; result false +3 != 2 ; result true +3 > 2 ; result true +3 < 2 ; result false +2 <= 2 ; result true +2 >= 2 ; result true + +; +; Control Structures +; +; if +; Evaluate a block of code if a given condition is true. IF does not return any value, +; so cannot be used in an expression. +if a < 0 [print "a is negative"] + +; either +; Evaluate a block of code if a given condition is true, else evaluate an alternative +; block of code. If the last expressions in both blocks have the same type, EITHER can +; be used inside an expression. +either a < 0 [ + either a = 0 [ + msg: "zero" + ][ + msg: "negative" + ] +][ + msg: "positive" +] + +print ["a is " msg lf] + +; There is an alternative way to write this +; (Which is allowed because all code paths return a value of the same type): + +msg: either a < 0 [ + either a = 0 [ + "zero" + ][ + "negative" + ] + ][ + "positive" +] +print ["a is " msg lf] + +; until +; Loop over a block of code until the condition at end of block, is met. +; UNTIL does not return any value, so it cannot be used in an expression. +c: 5 +until [ + prin "o" + c: c - 1 + c = 0 ; the condition to end the until loop +] +; will output: +ooooo +; Note that the loop will always be evaluated at least once, even if the condition is +; not met from the beginning. + +; while +; While a given condition is met, evaluate a block of code. +; WHILE does not return any value, so it cannot be used in an expression. +c: 5 +while [c > 0][ + prin "o" + c: c - 1 +] +; will output: +ooooo + +; +; Functions +; +; function example +twice: function [a [integer!] /one return: [integer!]][ + c: 2 + a: a * c + either one [a + 1][a] +] +b: 3 +print twice b ; will output 6. + +; Import external files with #include and filenames start with a % sign +#include %includefile.red +; Now the functions in the included file can be used too. + +``` + +## Further Reading + +The main source for information about Red is the [Red language homepage](http://www.red-lang.org). + +The source can be found on [github](https://github.com/red/red). + +The Red/System language specification can be found [here](http://static.red-lang.org/red-system-specs-light.html). + +To learn more about Rebol and Red join the [chat on Gitter](https://gitter.im/red/red). And if that is not working for you drop a mail to us on the [Red mailing list](mailto: red-langNO_SPAM@googlegroups.com) (remove NO_SPAM). + +Browse or ask questions on [Stack Overflow](stackoverflow.com/questions/tagged/red). + +Maybe you want to try Red right away? That is possible on the [try Rebol and Red site](http://tryrebol.esperconsultancy.nl). + +You can also learn Red by learning some [Rebol](http://www.rebol.com/docs.html). diff --git a/ro-ro/bash-ro.html.markdown b/ro-ro/bash-ro.html.markdown new file mode 100644 index 00000000..debeb67a --- /dev/null +++ b/ro-ro/bash-ro.html.markdown @@ -0,0 +1,177 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] +translators: + - ["Adrian Bordinc", "https://github.com/ellimist"] +lang: ro-ro +filename: LearnBash-ro.sh +--- + +Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X. +Aproape toate exemplele de mai jos pot fi parte dintr-un script sau pot fi executate direct in linia de comanda. + +[Citeste mai multe:](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Prima linie din script se numeste "shebang" +# care spune systemului cum sa execute scriptul +# http://en.wikipedia.org/wiki/Shebang_(Unix) +# Dupa cum te-ai prins deja, comentariile incep cu #. +# Shebang este de asemenea un comentariu. + +# Exemplu simplu de hello world: +echo Hello world! + +# Fiecare comanda incepe pe o linie noua, sau dupa punct si virgula ; +echo 'Prima linie'; echo 'A doua linie' + +# Declararea unei variabile se face astfel: +VARIABLE="Niste text" + +# DAR nu asa: +VARIABLE = "Niste text" +# Bash va crede ca VARIABLE este o comanda care trebuie executata si va +# returna o eroare pentru ca nu va putea fi gasita. + +# Folosind variabila: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, +# numele ei se scrie fara $. +# Daca vrei sa folosesti valoarea variabilei, atunci trebuie sa folosesti $. +# Atentie la faptul ca ' (apostrof) nu va inlocui variabla cu valoarea ei. + +# Inlocuirea de caractere in variabile +echo ${VARIABLE/Some/A} +# Asta va inlocui prima aparitie a "Some" cu "A" in variabila de mai sus. + +# Substring dintr-o variabila +echo ${VARIABLE:0:7} +# Asta va returna numai primele 7 caractere din variabila. + +# Valoarea implicita a unei variabile: +echo ${FOO:-"ValoareaImplicitaDacaFOOLipsesteSauEGoala"} +# Asta functioneaza pentru null (FOO=), +# sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0 + +# Variabile pre-existente +echo "Ulima valoare returnata de ultimul program rulat: $?" +echo "ID-ul procesului (PID) care ruleaza scriptul: $$" +echo "Numarul de argumente: $#" +echo "Argumentele scriptului: $@" +echo "Argumentele scriptului separate in variabile: $1 $2..." + +# Citind o valoare din consola +echo "Care e numele tau?" +read NAME # Observa faptul ca nu a trebuit sa declaram o variabila noua +echo Salut, $NAME! + +# Avem obisnuita instructiune "if" +# Foloseste "man test" pentru mai multe informatii +# despre instructinea conditionala +if [ $NAME -ne $USER ] +then + echo "Numele tau este username-ul tau" +else + echo "Numele tau nu este username-ul tau" +fi + +# Este de asemenea si executarea conditionala de comenzi +echo "Intotdeauna executat" || echo "Executat daca prima instructiune esueaza" +echo "Intotdeauna executat" && echo "Executat daca prima instructiune NU esueaza" + +# Expresiile apar in urmatorul format +echo $(( 10 + 5 )) + +# Spre deosebire de alte limbaje de programare bash este un shell - asa ca +# functioneaza in contextul directorului curent. Poti vedea fisiere si directoare +# din directorul curent folosind comanda "ls": +ls + +# Aceste comenzi au optiuni care la controleaza executia +ls -l # Listeaza fiecare fisier si director pe o linie separata + +# Rezultatele comenzii anterioare pot fi +# trimise urmatoarei comenzi drept argument +# Comanda grep filtreaza argumentele trimise cu sabloane. +# Astfel putem vedea fiserele .txt din directorul curent. +ls -l | grep "\.txt" + +# De asemenea poti redirectiona o comanda, input si error output +python2 hello.py < "input.in" +python2 hello.py > "output.out" +python2 hello.py 2> "error.err" +# Output-ul va suprascrie fisierul daca acesta exista. +# Daca vrei sa fie concatenate poti folosi ">>" + +# Comenzile pot fi inlocuite in interiorul altor comenzi folosind $( ): +# Urmatoarea comanda afiseaza numarul de fisiere +# si directoare din directorul curent +echo "Sunt $(ls | wc -l) fisiere aici." + +# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``, +# dar nu pot fi folosite unele in interiorul celorlalte asa ca modalitatea +# preferata este de a folosi $( ) +echo "Sunt `ls | wc -l` fisiere aici." + +# Bash foloseste o instructiune 'case' care functioneaza +# in mod similar cu instructiunea switch din Java si C++ +case "$VARIABLE" in + 0) echo "Este un zero.";; + 1) echo "Este un unu.";; + *) echo "Nu este null";; +esac + +# Instructiunea for parcurge toate elementele trimise: +# Continutul variabilei $VARIABLE este printat de 3 ori +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# while loop: +while [true] +do + echo "in interiorul iteratiei aici..." + break +done + +# De asemenea poti defini functii +# Definitie: +function foo () +{ + echo "Argumentele functioneaza ca si argumentele scriptului: $@" + echo "Si: $1 $2..." + echo "Asta este o functie" + return 0 +} + +# sau mai simplu +bar () +{ + echo "Alta metoda de a declara o functie" + return 0 +} + +# Invocarea unei functii +foo "Numele meu este: " $NAME + +# Sunt o multime de comenzi utile pe care ar trebui sa le inveti: +tail -n 10 file.txt +# printeaza ultimele 10 linii din fisierul file.txt +head -n 10 file.txt +# printeaza primele 10 linii din fisierul file.txt +sort file.txt +# sorteaza liniile din file.txt +uniq -d file.txt +# raporteaza sau omite liniile care se repeta, cu -d le raporteaza +cut -d ',' -f 1 file.txt +# printeaza doar prima coloana inainte de caracterul "," +``` diff --git a/ro-ro/clojure-ro.html.markdown b/ro-ro/clojure-ro.html.markdown new file mode 100644 index 00000000..32ba9620 --- /dev/null +++ b/ro-ro/clojure-ro.html.markdown @@ -0,0 +1,386 @@ +--- +language: clojure +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Bogdan Paun", "http://twitter.com/bgdnpn"] +filename: learnclojure-ro.clj +lang: ro-ro +--- + +Clojure este un limbaj din familia Lisp dezvoltat pentru Masina Virtuala Java +(Java Virtual Machine - JVM). Pune un accent mult mai puternic pe +[programarea funcionala](https://en.wikipedia.org/wiki/Functional_programming) +pura decat Common Lisp, dar include utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) +pentru a gestiona starea, atunci cand aceasta apare. + +Combinatia aceasta ii permite sa gestioneze procese concurente foarte usor, +de multe ori in mod automat. + +(Aveti nevoie deo versiune Clojure 1.2 sau mai noua) + + +```clojure +; Comentariile incep cu punct si virgula. + +; Clojure se scrie in "forme", care nu sunt decat +; liste de lucruri in interiorul unor paranteze, separate prin spatii. +; +; Reader-ul Clojure presupune ca primul lucru este o +; functie sau un macro de apelat, iar restul sunt argumente. + +; Prima apelare intr-un fisier ar trebui sa fie ns, pentru a configura namespace-ul +(ns learnclojure) + +; Mai multe exemple de baza: + +; str va crea un string folosint toate argumentele sale +(str "Hello" " " "World") ; => "Hello World" + +; Matematica este simpla +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; Egalitatea este = +(= 1 1) ; => true +(= 2 1) ; => false + +; Folosim si not pentru logica +(not true) ; => false + +; Formele imbricate functioneaza asa +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; Tipuri +;;;;;;;;;;;;; + +; Clojure foloseste sistemul de obiecte Java pentru boolean, string si numere. +; Folositi `class` pentru a le inspecta. +(class 1) ; Numere intregi sunt jaba.lang.Long, in mod normal +(class 1.); Numelere reale sunt java.lang.Double +(class ""); Sirurile de caractere sunt mere intre apostrofuri duble, si sunt java.lang.String +(class false) ; Booleanele sunt java.lang.Boolean +(class nil); Valoarea "null" este numita nil + +; Daca doriti sa creati o lista de date literale, folositi ' pentru a preveni +; evaluarea ei +'(+ 1 2) ; => (+ 1 2) +; (prescurtare pentru (quote (+ 1 2))) + +; Puteti evalua o lista cu apostrof +(eval '(+ 1 2)) ; => 3 + +; Colectii & Secvente +;;;;;;;;;;;;;;;;;;; + +; Listele sunt structuri de date lista-inlantuita, spre deosebire de Vectori +; Vectorii si Listele sunt si ele clase Java! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; O liste ar putea fi scrisa direct ca (1 2 3), dar trebuie sa folosim apostrof +; pentru a preveni reader-ul din a crede ca e o functie. +; De asemenea, (list 1 2 3) este acelasi lucru cu '(1 2 3) + +; "Colectiile" sunt grupuri de date +; Atat listele cat si vectorii sunt colectii: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; "Sequences" (seqs) are abstract descriptions of lists of data. +; Only lists are seqs. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; O secventa necesita un punct de intrare doar cand este accesata. +; Deci, secventele, care pot fi "lazy" -- pot defini serii infinite: +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (o serie infinita) +(take 4 (range)) ; (0 1 2 3) + +; Folositi cons pentru a adauga un element la inceputul unei liste sau unui vector +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; Conj va adauga un element unei colectii in modul cel mai eficient. +; Pentru liste, aceastea sunt inserate la inceput. Pentru vectori, sunt inserate la final. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; Folositi concat pentru a uni liste sau vectori +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; Folositi filter, map pentru a interactiona cu colectiile +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; Folositi reduce pentru a le reduce +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; Reduce poate lua un argument valoare-initiala +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; Functii +;;;;;;;;;;;;;;;;;;;;; + +; Folositi fn pentru a crea functii noi. O functie returneaza intotdeauna +; ultima sa instructiune. +(fn [] "Hello World") ; => fn + +; (Necesita paranteze suplimentare pentru a fi apelata) +((fn [] "Hello World")) ; => "Hello World" + +; Puteti crea o variabila folosind def +(def x 1) +x ; => 1 + +; Atribuiti o functie unei variabile +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; Puteti scurta acest proces folosind defn +(defn hello-world [] "Hello World") + +; Elementul [] este lista de argumente a functiei. +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; Puteti, de asemenea, folosi aceasta prescurtare pentru a crea functii: +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; Puteti avea si functii cu mai multe variabile +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; Functiile pot primi mai mult argumente dintr-o secventa +(defn count-args [& args] + (str "Ati specificat " (count args) " argumente: " args)) +(count-args 1 2 3) ; => "Ati specificat 3 argumente: (1 2 3)" + +; Puteti interschimba argumente normale si argumente-secventa +(defn hello-count [name & args] + (str "Salut " name ", ati specificat " (count args) " argumente extra")) +(hello-count "Finn" 1 2 3) +; => "Salut Finn, ai specificat 3 argumente extra" + + +; Maps (Dictionare) +;;;;;;;;;; + +; Hash maps si Array maps impart o interfata. Hash maps au cautari mai rapide +; dar nu retin ordinea cheilor. +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; Arraymaps de vin automat hashmaps prin majoritatea operatiilor +; daca sunt suficient de mari, asa ca nu trebuie sa va preocupe acest aspect. + +; Dictionarele pot folosi orice tip hashable ca si cheie, dar cuvintele cheie +; (keywords) sunt, de obicei, cele mai indicate. Cuvintele cheie sunt ca niste +; siruri de caractere cu un plus de eficienta +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; Apropo, virgulele sunt intotdeauna considerate echivalente cu spatiile. + +; Apelati un dictionar (map) ca pe o functie pentru a primi o valoare anume +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; Cuvintele cheie pot fi folosite si ele pentru a "cere" dictionarului valorile lor! +(:b keymap) ; => 2 + +; Nu incercati asta cu siruri de caractere. +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; Recuperarea unei chei inexistente returneaza nil +(stringmap "d") ; => nil + +; Folositi assoc pentru a adauga nou chei unui ductionar +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; Dar retineti ca tipurile sunt imuabile in clojure +keymap ; => {:a 1, :b 2, :c 3} + +; Folositi dissoc pentru a elimina chei +(dissoc keymap :a :b) ; => {:c 3} + +; Seturi (multimi) +;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; Adaugati un membru cu conj +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; Eliminati unul cu disj +(disj #{1 2 3} 1) ; => #{2 3} + +; Testati existenta unuia folosing setul ca o functie: +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; Exista mai multe functii in namespace-ul clojure.sets. + +; Forme utile +;;;;;;;;;;;;;;;;; + +; In Clojure constructiile logice sunt macro-uri, si arata ca +; oricare alta forma +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; Folositi let pentru a crea atribuiri temporare +(let [a 1 b 2] + (> a b)) ; => false + +; Grupati instructiuni impreuna folosind do +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; Functiile contin un do implicit +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; Asemanator pentru let +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; Module +;;;;;;;;;;;;;;; + +; Folositi "use" pentru a recupera toate functiile dintr-un modul +(use 'clojure.set) + +; Acum putem folosi operatiuni pe seturi +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; Puteri de asemenea alege un subset al functiilor de importat +(use '[clojure.set :only [intersection]]) + +; Folositi require pentru a importa un modul +(require 'clojure.string) + +; Folositi / pentru a apela functii dintr-un modul +; In acest caz, modulul este clojure.string, iar functia este blank? +(clojure.string/blank? "") ; => true + +; Puteti atribui un nume mai scurt unui modul in momentul importului +(require '[clojure.string :as str]) +(str/replace "Acesta este un test." #"[a-o]" str/upper-case) ; => "ACEstA EstE un tEst." +; (#"" denota o expresie regulata) + +; Puteti folsi require (sau use, contraindicat) dintr-un namespace folosind :require. +; Nu trebuie sa folositi apostrof pentru module daca procedati astfel. +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java are o biblioteca standard imensa si folositoare, deci +; ar fi util sa stiti cum sa o folositi. + +; Folositi import pentru a incarca un modul Java +(import java.util.Date) + +; Puteti importa si dintr-un namesopace. +(ns test + (:import java.util.Date + java.util.Calendar)) + +; Folositi numele clasei cu "." la final pentru a crea o noua instanta +(Date.) ; <a date object> + +; Folositi . pentru a apela metode. Pe scurt, folositi ".method" +(. (Date.) getTime) ; <a timestamp> +(.getTime (Date.)) ; exact acelasi lucru. + +; Folositi / pentru a apela metode statice +(System/currentTimeMillis) ; <a timestamp> (System este prezent intotdeauna) + +; Folositi doto pentru a gestiona clase (mutable) mai usor +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; Software Transactional Memory este un mecanism folost de Clojure pentru +; a gestiona stari persistente. Sunt putine instante in care este folosit. + +; Un atom este cel mai simplu exemplu. Dati-i o valoare initiala +(def my-atom (atom {})) + +; Modificati-l cu swap!. +; swap! primeste o functie si o apeleaza cu valoarea actuala a atomului +; ca prim argument si orice argumente suplimentare ca al doilea +(swap! my-atom assoc :a 1) ; Atomul ia valoarea rezultata din (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Atomul ia valoarea rezultata din (assoc {:a 1} :b 2) + +; Folositi '@' pentru a dereferentia atomul si a-i recupera valoarea +my-atom ;=> Atom<#...> (Returmeaza obiectul Atom) +@my-atom ; => {:a 1 :b 2} + +; Aici avem un contor simplu care foloseste un atom +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; Alte utilizari ale STM sunt referintele (refs) si agentii (agents). +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### Lectura suplimentara + +Lista nu este in niciun caz exhaustiva, dar speram ca este suficienta pentru +a va oferi un inceput bun in Clojure. + +Clojure.org contine multe articole: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org contine documentatie cu exemple pentru majoritatea functiilor de baza: +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure este o metoda excelenta pentru a exersa Clojure/FP (Programarea Functionala): +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org are un numar de article pentru incepatori: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown new file mode 100644 index 00000000..125ba2f4 --- /dev/null +++ b/ro-ro/python-ro.html.markdown @@ -0,0 +1,490 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Ovidiu Ciule", "https://github.com/ociule"] +filename: learnpython-ro.py +lang: ro-ro +--- + +Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din +cele mai populare limbaje de programare. M-am indrăgostit de Python pentru claritatea sa sintactică. +Python este aproape pseudocod executabil. + +Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service] + +Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea +în curând, în limba engleză mai întâi. + +```python +# Comentariile pe o singură linie încep cu un caracter diez. +""" Şirurile de caractere pe mai multe linii pot fi încadrate folosind trei caractere ", şi sunt des + folosite ca şi comentarii pe mai multe linii. +""" + +#################################################### +## 1. Operatori şi tipuri de date primare +#################################################### + +# Avem numere +3 #=> 3 + +# Matematica se comportă cum ne-am aştepta +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere întregi şi rotunjeşte +# automat spre valoarea mai mică +5 / 2 #=> 2 + +# Pentru a folosi împărţirea fără rest avem nevoie de numere reale +2.0 # Acesta e un număr real +11.0 / 4.0 #=> 2.75 ahhh ... cum ne aşteptam + +# Ordinea operaţiilor se poate forţa cu paranteze +(1 + 3) * 2 #=> 8 + +# Valoriile boolene sunt şi ele valori primare +True +False + +# Pot fi negate cu operatorul not +not True #=> False +not False #=> True + +# Egalitatea este == +1 == 1 #=> True +2 == 1 #=> False + +# Inegalitate este != +1 != 1 #=> False +2 != 1 #=> True + +# Comparaţii +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Comparaţiile pot fi inlănţuite! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Şirurile de caractere pot fi încadrate cu " sau ' +"Acesta e un şir de caractere." +'Şi acesta este un şir de caractere.' + +# Şirurile de caractere pot fi adăugate! +"Hello " + "world!" #=> "Hello world!" + +# Un şir de caractere poate fi folosit ca o listă +"Acesta e un şir de caractere"[0] #=> 'A' + +# Caracterul % (procent) poate fi folosit pentru a formata şiruri de caractere : +"%s pot fi %s" % ("şirurile", "interpolate") + +# O metodă mai nouă de a formata şiruri este metoda "format" +# Este metoda recomandată +"{0} pot fi {1}".format("şirurile", "formatate") +# Puteţi folosi cuvinte cheie dacă nu doriţi sa număraţi +"{nume} vrea să mănânce {fel}".format(nume="Bob", fel="lasagna") + +# "None", care reprezintă valoarea nedefinită, e un obiect +None #=> None + +# Nu folosiţi operatorul == pentru a compara un obiect cu None +# Folosiţi operatorul "is" +"etc" is None #=> False +None is None #=> True + +# Operatorul "is" testeaza dacă obiectele sunt identice. +# Acastă operaţie nu e foarte folositoare cu tipuri primare, +# dar e foarte folositoare cu obiecte. + +# None, 0, şi şiruri de caractere goale sunt evaluate ca si fals, False. +# Toate celelalte valori sunt adevărate, True. +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variabile şi colecţii +#################################################### + +# Printarea este uşoară +print "Eu sunt Python. Încântat de cunoştinţă!" + + +# Nu este nevoie sa declari variabilele înainte de a le folosi +o_variabila = 5 # Convenţia este de a folosi caractere_minuscule_cu_underscore +o_variabila #=> 5 + +# Dacă accesăm o variabilă nefolosită declanşăm o excepţie. +# Vezi secţiunea Control de Execuţie pentru mai multe detalii despre excepţii. +alta_variabila # Declanşează o eroare de nume + +# "If" poate fi folosit într-o expresie. +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listele sunt folosite pentru colecţii +li = [] +# O listă poate avea valori de la început +alta_li = [4, 5, 6] + +# Se adaugă valori la sfârşitul lister cu append +li.append(1) #li e acum [1] +li.append(2) #li e acum [1, 2] +li.append(4) #li e acum [1, 2, 4] +li.append(3) #li este acum [1, 2, 4, 3] +# Se şterg de la sfarşit cu pop +li.pop() #=> 3 şi li e acum [1, 2, 4] +# Să o adaugăm înapoi valoarea +li.append(3) # li e din nou [1, 2, 4, 3] + +# Putem accesa valorile individuale dintr-o listă cu operatorul index +li[0] #=> 1 +# Valoarea speciala -1 pentru index accesează ultima valoare +li[-1] #=> 3 + +# Dacă depaşim limitele listei declanşăm o eroare IndexError +li[4] # Declanşează IndexError + +# Putem să ne uităm la intervale folosind sintaxa de "felii" +# În Python, intervalele sunt închise la început si deschise la sfârşit. +li[1:3] #=> [2, 4] +# Fără început +li[2:] #=> [4, 3] +# Fără sfarşit +li[:3] #=> [1, 2, 4] + +# Putem şterge elemente arbitrare din lista cu operatorul "del" care primeşte indexul lor +del li[2] # li e acum [1, 2, 3] + +# Listele pot fi adăugate +li + alta_li #=> [1, 2, 3, 4, 5, 6] - Notă: li si alta_li nu sunt modificate! + +# Concatenăm liste cu "extend()" +li.extend(alta_li) # Acum li este [1, 2, 3, 4, 5, 6] + +# Se verifică existenţa valorilor in lista cu "in" +1 in li #=> True + +# Şi lungimea cu "len()" +len(li) #=> 6 + + +# Tuplele sunt ca şi listele dar imutabile +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Declanşează TypeError + +# Pot fi folosite ca şi liste +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Tuplele pot fi despachetate +a, b, c = (1, 2, 3) # a este acum 1, b este acum 2 şi c este acum 3 +# Tuplele pot fi folosite şi fără paranteze +d, e, f = 4, 5, 6 +# Putem inversa valori foarte uşor! +e, d = d, e # d este acum 5 şi e este acum 4 + + +# Dicţionarele stochează chei şi o valoare pentru fiecare cheie +dict_gol = {} +# Şi un dicţionar cu valori +dict_cu_valori = {"unu": 1, "doi": 2, "trei": 3} + +# Căutaţi valori cu [] +dict_cu_valori["unu"] #=> 1 + +# Obţinem lista cheilor cu "keys()" +dict_cu_valori.keys() #=> ["trei", "doi", "unu"] +# Notă - ordinea cheilor obţinute cu keys() nu este garantată. +# Puteţi obţine rezultate diferite de exemplul de aici. + +# Obţinem valorile cu values() +dict_cu_valori.values() #=> [3, 2, 1] +# Notă - aceeaşi ca mai sus, aplicată asupra valorilor. + +# Verificăm existenţa unei valori cu "in" +"unu" in dict_cu_valori #=> True +1 in dict_cu_valori #=> False + +# Accesarea unei chei care nu exista declanşează o KeyError +dict_cu_valori["four"] # KeyError + +# Putem folosi metoda "get()" pentru a evita KeyError +dict_cu_valori.get("one") #=> 1 +dict_cu_valori.get("four") #=> None +# Metoda get poate primi ca al doilea argument o valoare care va fi returnată +# când cheia nu este prezentă. +dict_cu_valori.get("one", 4) #=> 1 +dict_cu_valori.get("four", 4) #=> 4 + +# "setdefault()" este o metodă pentru a adăuga chei-valori fără a le modifica, dacă cheia există deja +dict_cu_valori.setdefault("five", 5) #dict_cu_valori["five"] este acum 5 +dict_cu_valori.setdefault("five", 6) #dict_cu_valori["five"] exista deja, nu este modificată, tot 5 + + +# Set este colecţia mulţime +set_gol = set() +# Putem crea un set cu valori +un_set = set([1,2,2,3,4]) # un_set este acum set([1, 2, 3, 4]), amintiţi-vă ca mulţimile garantează unicatul! + +# În Python 2.7, {} poate fi folosit pentru un set +set_cu_valori = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Putem adăuga valori cu add +set_cu_valori.add(5) # set_cu_valori este acum {1, 2, 3, 4, 5} + +# Putem intersecta seturi +alt_set = {3, 4, 5, 6} +set_cu_valori & alt_set #=> {3, 4, 5} + +# Putem calcula uniunea cu | +set_cu_valori | alt_set #=> {1, 2, 3, 4, 5, 6} + +# Diferenţa între seturi se face cu - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Verificăm existenţa cu "in" +2 in set_cu_valori #=> True +10 in set_cu_valori #=> False + + +#################################################### +## 3. Controlul Execuţiei +#################################################### + +# O variabilă +o_variabila = 5 + +# Acesta este un "if". Indentarea este importanta în python! +# Printează "o_variabila este mai mică ca 10" +if o_variabila > 10: + print "o_variabila e mai mare ca 10." +elif o_variabila < 10: # Clauza elif e opţională. + print "o_variabila este mai mică ca 10." +else: # Şi else e opţional. + print "o_variabila este exact 10." + + +""" +Buclele "for" pot fi folosite pentru a parcurge liste +Vom afişa: + câinele este un mamifer + pisica este un mamifer + şoarecele este un mamifer +""" +for animal in ["câinele", "pisica", "şoarecele"]: + # Folosim % pentru a compune mesajul + print "%s este un mamifer" % animal + +""" +"range(număr)" crează o lista de numere +de la zero la numărul dat +afişează: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +While repetă pana când condiţia dată nu mai este adevărată. +afişează: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Prescurtare pentru x = x + 1 + +# Recepţionăm excepţii cu blocuri try/except + +# Acest cod e valid in Python > 2.6: +try: + # Folosim "raise" pentru a declanşa o eroare + raise IndexError("Asta este o IndexError") +except IndexError as e: + pass # Pass nu face nimic. În mod normal aici ne-am ocupa de eroare. + + +#################################################### +## 4. Funcţii +#################################################### + +# Folosim "def" pentru a defini funcţii +def add(x, y): + print "x este %s şi y este %s" % (x, y) + return x + y # Funcţia poate returna valori cu "return" + +# Apelăm funcţia "add" cu parametrii +add(5, 6) #=> Va afişa "x este 5 şi y este 6" şi va returna 11 + +# Altă cale de a apela funcţii: cu parametrii numiţi +add(y=6, x=5) # Ordinea parametrilor numiţi nu contează + +# Putem defini funcţii care primesc un număr variabil de parametrii nenumiţi +# Aceşti parametrii nenumiţi se cheamă si poziţinali +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Şi putem defini funcţii care primesc un număr variabil de parametrii numiţi +def keyword_args(**kwargs): + return kwargs + +# Hai să vedem cum merge +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Se pot combina +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) va afişa: + (1, 2) + {"a": 3, "b": 4} +""" + +# Când apelăm funcţii, putem face inversul args/kwargs! +# Folosim * pentru a expanda tuple şi ** pentru a expanda kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # echivalent cu foo(1, 2, 3, 4) +all_the_args(**kwargs) # echivalent cu foo(a=3, b=4) +all_the_args(*args, **kwargs) # echivalent cu foo(1, 2, 3, 4, a=3, b=4) + +# În Python, funcţiile sunt obiecte primare +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Funcţiile pot fi anonime +(lambda x: x > 2)(3) #=> True + +# Există funcţii de ordin superior (care operează pe alte funcţii) predefinite +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Putem folosi scurtături de liste pentru a simplifica munca cu map si filter +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Clase +#################################################### + +# Moştenim object pentru a crea o nouă clasă +class Om(object): + + # Acesta este un atribut al clasei. Va fi moştenit de toate instanţele. + species = "H. sapiens" + + # Constructor (mai degrabă, configurator de bază) + def __init__(self, nume): + # Valoarea parametrului este stocată in atributul instanţei + self.nume = nume + + # Aceasta este o metoda a instanţei. + # Toate metodele primesc "self" ca si primul argument. + def spune(self, mesaj): + return "%s: %s" % (self.nume, mesaj) + + # O metodă a clasei. Este partajată de toate instanţele. + # Va primi ca si primul argument clasa căreia îi aparţine. + @classmethod + def get_species(cls): + return cls.species + + # O metoda statica nu primeste un argument automat. + @staticmethod + def exclama(): + return "*Aaaaaah*" + + +# Instanţiem o clasă +i = Om(nume="Ion") +print i.spune("salut") # afişează: "Ion: salut" + +j = Om("George") +print j.spune("ciau") # afişează George: ciau" + +# Apelăm metoda clasei +i.get_species() #=> "H. sapiens" + +# Modificăm atributul partajat +Om.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Apelăm metoda statică +Om.exclama() #=> "*Aaaaaah*" + + +#################################################### +## 6. Module +#################################################### + +# Pentru a folosi un modul, trebuie importat +import math +print math.sqrt(16) #=> 4 + +# Putem importa doar anumite funcţii dintr-un modul +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Putem importa toate funcţiile dintr-un modul, dar nu este o idee bună +# Nu faceţi asta! +from math import * + +# Numele modulelor pot fi modificate la import, de exemplu pentru a le scurta +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Modulele python sunt pur şi simplu fişiere cu cod python. +# Puteţi sa creaţi modulele voastre, şi sa le importaţi. +# Numele modulului este acelasi cu numele fişierului. + +# Cu "dir" inspectăm ce funcţii conţine un modul +import math +dir(math) + + +``` + +## Doriţi mai mult? + +### Gratis online, în limba engleză + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Cărţi, în limba engleză + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/ro-ro/ruby-ro.html.markdown b/ro-ro/ruby-ro.html.markdown new file mode 100644 index 00000000..12672b68 --- /dev/null +++ b/ro-ro/ruby-ro.html.markdown @@ -0,0 +1,491 @@ +--- +language: ruby +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] + - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"] +translators: + - ["Adrian Bordinc", "https://github.com/ellimist"] +filename: learnruby-ro.rb +lang: ro-ro +--- + +```ruby +# Acesta este un comentariu + +=begin +Acesta este un comentariu pe mai multe linii +Nimeni nu le foloseste +Si nici tu nu ar trebui sa o faci +=end + +# In primul rand: totul este un obiect + +# Numerele sunt obiecte + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Aritmetica de baza +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Aritmetica este doar "zahar sintactic" +# pentru a putea chema metode pe un obiect +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Valorile speciale sunt obiecte +nil # Nimic +true # true +false # false + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Egalitate +1 == 1 #=> true +2 == 1 #=> false + +# Inegalitate +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# Excluzand "false", "nil" este singura valoare "falsa" + +!nil #=> true +!false #=> true +!0 #=> false + +# Mai multe comparatii +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Sirurule de caractere sunt obiecte + +'Sunt un sir de caractere'.class #=> String +"Si eu sunt un sir de caractere".class #=> String + +fi_inlocuit = "fi inlocuit" +"Pot #{fi_inlocuit} atunci cand folosesc dublu apostrof" +#=> "Pot fi inlocuit atunci cand folosesc dublu apostrof" + + +# Printeaza +puts "Afisez rezultate!" + +# Variabile +x = 25 #=> 25 +x #=> 25 + +# Retineti faptul ca atribuire unei valori, o si returneaza pe aceasta +# Asta inseamna ca poti sa faci atribuire multipla: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Prin conventie se foloseste "snake_case" in denumirea variabilelor +snake_case = true + +# Folositi nume descriptive pentru variablie +adresa_radacina_proiect = '/nume/bun/' +adresa = '/nume/nu atat de bun/' + +# Simbolurile (sunt obiecte) +# Simbolurile sunt constante imutabile, reutilizabile, reprezentate intern +# de o valoare numerica. Sunt deseori folosite in locul sirurilor de caractere +# pentru a da un nume reprezentativ unei valori + +:exemplu_simbol.class #=> Symbol + +status = :exemplu_simbol + +status == :exemplu_simbol #=> adevarat + +status == 'exemplu_simbol' #=> fals + +status == :aprobat #=> fals + +# Vectori + +# Acesta este un vector +vector = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Vectorii pot contine diferite tipuri de date + +[1, "salut", false] #=> [1, "salut", false] + +# Vectorii pot fi indexati +# de la inceput +vector[0] #=> 1 +vector[12] #=> nil + +# Ca si aritmetica, accessul [valoare] +# este doar "zahar sintactic" +# pentru a chema metoda [] a unui obiect +vector.[] 0 #=> 1 +vector.[] 12 #=> nil + +# De la sfarsit +vector[-1] #=> 5 + +# Cu un index de inceput si o lungime +vector[2, 3] #=> [3, 4, 5] + +# Sau cu un interval +vector[1..3] #=> [2, 3, 4] + +# Adauga elemente intr-un vector in felul urmator: +vector << 6 #=> [1, 2, 3, 4, 5, 6] + +# Hash-urile sunt dictionarele din Ruby cu perechi cheie/valoare. +# Hash-urile sunt notate cu acolade +hash = {'culoare' => 'verde', 'numar' => 5} + +hash.keys #=> ['culoare', 'numar'] + +# Poti lua valoare unui element dintr-un hash foarte rapid folosind cheia +hash['culoare'] #=> 'verde' +hash['numar'] #=> 5 + +# Incercand sa accesezi un element dintr-un hash +# printr-o cheie care nu exista va returna "nil". +hash['nimic_aici'] #=> nil + +# Incepand cu Ruby 1.9, este o sintaxa speciala +# pentru atunci cand se folosesc simboluri drept chei: + +hash_nou = { defcon: 3, actiune: true} + +hash_now.keys #=> [:defcon, :actiune] + +# Pont: Atat vectorii (Array) si hash-urile (Hash) sunt enumerabile (Enumerable) +# Ele impart o multime de metode utile precum each, map, count si altele + + +# Structuri de control + +if true + "instructiune if" +elsif false + "else if, optional" +else + "else, de asemenea optional" +end + +for numar in 1..5 + puts "iteratia #{numar}" +end +#=> iteratia 1 +#=> iteratia 2 +#=> iteratia 3 +#=> iteratia 4 +#=> iteratia 5 + +# TOTUSI, Nici una nu foloseste instructiunea for +# In locul acesteia ar trebui sa folosesti metoda "each" si sa ii trimiti un block +# Un bloc este o bucata de cod pe care o poti trimite unei metode precum "each". +# Este analog pentru "lambda", functii anonime, +# sau closures in alte limbaje de programare. +# +# Metoda "each" a unui interval, ruleaza block-ul o data +# pentru fiecare element din interval. +# Block-ul primeste ca si parametru un index +# Invocand metoda "each" cu un block, arata in urmatorul fel: + +(1..5).each do |index| + puts "iteratia #{index}" +end +#=> iteratia 1 +#=> iteratia 2 +#=> iteratia 3 +#=> iteratia 4 +#=> iteratia 5 + +# Poti de asemenea sa pui block-ul intre acolade +(1..5).each {|index| puts "iteratia #{index}"} + +# Continutul unei structuri de date poate fi parcurs folosind "each". +array.each do |element| + puts "#{element} parte din vector" +end +hash.each do |cheie, valoare| + puts "#{cheie} este #{valoare}" +end + +index = 1 +while index <= 5 do + puts "iteratia #{index}" + index += 1 +end +#=> iteratia 1 +#=> iteratia 2 +#=> iteratia 3 +#=> iteratia 4 +#=> iteratia 5 + +nota = 'B' + +case nota +when 'A' + puts "Bravo pustiule!" +when 'B' + puts "Mai mult noroc data viitoare" +when 'C' + puts "Poti mai mult" +when 'D' + puts "Incet, incet..." +when 'F' + puts "Ai esuat!" +else + puts "Sistem de notare alternativ?!" +end + +# Functii + +def dublu(x) + x * 2 +end + +# Functille (si toate block-urile) +# returneaza implicit valoarea ultimei instructiuni +dublu(2) #=> 4 + +# Parantezele sunt optionale cand rezultatul nu este ambiguu +dublu 3 #=> 6 + +dublu dublu 3 #=> 12 + +def suma(x,y) + x + y +end + +# Argumentele metodei sunt separate printr-o virgula +suma 3, 4 #=> 7 + +suma suma(3,4), 5 #=> 12 + +# yield +# Toate metodele au un parametru block, implicit si optional +# care poate fi invocat folosit cuvantul cheie 'yield' + +def incercuieste + puts "{" + yield + puts "}" +end + +incercuieste { puts 'Salut Mihai!' } + +# { +# Salut Mihai! +# } + + +# Poti trimite un block unei functii. +# "&" marcheaza o referinta trimisa unui block +def vizitatori(&block) + block.call "un_parametru" +end + +# Poti trimite o lista de argumente, care va fi convertita intr-un vector (array). +# Pentru asta se foloseste ("*") +def vizitatori(*vector) + vector.each { |vizitator| puts "#{vizitator}" } +end + +# Defineste o clasa folosind cuvantul cheie "class" +class Om + + # O variabila apartinand clasei. Este folosita in toate instantele clasei + @@specie = "H. sapiens" + + # Constructor + def initialize(nume, varsta=0) + # Atribuie argumentul, variabilei "nume", care apartine doar unei instante + @nume = nume + # Daca varsta nu este data, o sa ii atribuim valoarea implicita + # din lista de argumente (0, in cazul nostru) + @varsta = varsta + end + + # Metoda pentru a seta valoarea unei variabile + def nume=(nume) + @nume = nume + end + + # Metoda pentru a lua valoarea unei variabile + def nume + @nume + end + + # Functionalitatea de mai sus poate fi obtinuta + # folosing metoda "attr_accessor" dupa cum urmeaza: + attr_accessor :nume + + # Metodele pentru a lua si a seta valoarea unei variabile + # pot fi de asemenea obtinute individial: + attr_reader :nume + attr_writer :nume + + # O metoda apartinand unei clase foloseste "self" pentru a se diferentia + # de metodele unei instante ale clasei respective + # Poate fi invocata doar pe clasa, si nu pe o instanta a acesteia + def self.spune(msg) + puts "#{msg}" + end + + def specie + @@specie + end + +end + + +# Creaza o instanta a unei clase +ion = Om.new("Ionut Popescu") + +eugen = Om.new("Eugen Ionescu") + +# Sa invocam niste metode +ion.specie #=> "H. sapiens" +ion.nume #=> "Ionut Popescu" +ion.nume = "Ionut Popescu JR." #=> "Ionut Popescu JR." +ion.nume #=> "Ionut Popescu JR." +eugen.specie #=> "H. sapiens" +eugen.nume #=> "Eugen Ionescu" + +# Invoca o metoda a unei clase +Om.spune("Salut") #=> "Salut" + + +# Scopul unei variabile este definit de modul in care le numim +# Variabilele care incep cu $ au scop global +$var = "Sunt o variabila globala" +defined? $var #=> "global-variable" + +# Variabilele care incep cu @ apartin unei instante +@var = "Sunt o variabila a unei instante" +defined? @var #=> "instance-variable" + +# Variabilele care incep cu @@ apartin unei clase +@@var = "Sunt variabila unei clase" +defined? @@var #=> "class variable" + +# Variabilele care incep cu litera mare sunt constante +Var = "Sunt o constanta" +defined? Var #=> "constant" + +# Clasele sunt de asemenea obiecte in ruby. Astfel incat clasele +# pot avea variabile care apartin unei instante +# O variabila care apartine unei clase poate fi accesata de toate +# instantele acesteia si de clasele care o extind + +# clasa parinte +class Om + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(valoare) + @@foo = valoare + end +end + +# clasa copil +class Muncitor < Om +end + +Om.foo # 0 +Muncitor.foo # 0 + +Om.foo = 2 # 2 +Muncitor.foo # 2 + +# Variabilele care apartin unei instante ale unei clase, +# nu sunt impartite de (copii acesteia) clasele care o extind +class Om + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(valoare) + @bar = valoare + end +end + +class Doctor < Om +end + +Om.bar # 0 +Doctor.bar # nil + +module ExempluModul + def foo + 'foo' + end +end + +# Incluzand modulul instantei unui obiect +# Extinzand modulul unei instante ale unei clase + +class Persoana + include ExempluModul +end + +class Carte + extend ExempluModul +end + +Persoana.foo # => NoMethodError: undefined method `foo' for Persoana:Class +Persoana.new.foo # => 'foo' +Carte.foo # => 'foo' +Carte.new.foo # => NoMethodError: undefined method `foo' + +# Callbacks atunci cand includerea si extinderea unui modul sunt executate + +module ModulExempluCallBack + def self.included(base) + base.extend(ClassMethods) + base.send(:include, InstanceMethods) + end + + module ClassMethods + def bar + 'bar' + end + end + + module InstanceMethods + def qux + 'qux' + end + end +end + +class CevaRelevant + include ModulExempluCallBack +end + +CevaRelevant.bar # => 'bar' +CevaRelevant.qux # => NoMethodError: undefined method `qux' +CevaRelevant.new.bar # => NoMethodError: undefined method `bar' +CevaRelevant.new.qux # => 'qux' +``` diff --git a/ru-ru/bash-ru.html.markdown b/ru-ru/bash-ru.html.markdown new file mode 100644 index 00000000..21377b6c --- /dev/null +++ b/ru-ru/bash-ru.html.markdown @@ -0,0 +1,284 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] + - ["Etan Reisner", "https://github.com/deryni"] +translators: + - ["Andrey Samsonov", "https://github.com/kryzhovnik"] + - ["Andre Polykanine", "https://github.com/Oire"] +filename: LearnBash-ru.sh +lang: ru-ru +--- + +Bash - это командная оболочка unix (unix shell), которая распространялась как оболочка для операционной системы GNU и используется в качестве оболочки по умолчанию для Linux и Mac OS X. +Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell. + +[Подробнее.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Первая строка скрипта - это shebang, который сообщает системе, как исполнять +# этот скрипт: http://en.wikipedia.org/wiki/Shebang_(Unix) +# Как вы уже поняли, комментарии начинаются с #. Shebang - тоже комментарий. + +# Простой пример hello world: +echo Hello world! + +# Отдельные команды начинаются с новой строки или разделяются точкой с запятой: +echo 'Это первая строка'; echo 'Это вторая строка' + +# Вот так объявляется переменная: +VARIABLE="Просто строка" + +# но не так: +VARIABLE = "Просто строка" +# Bash решит, что VARIABLE - это команда, которую он должен исполнить, +# и выдаст ошибку, потому что не сможет найти ее. + +# и не так: +VARIABLE= 'Просто строка' +# Тут Bash решит, что 'Просто строка' - это команда, которую он должен исполнить, +# и выдаст ошибку, потому что не сможет найти такой команды +# (здесь 'VARIABLE=' выглядит как присвоение значения переменной, +# но только в контексте исполнения команды 'Просто строка'). + +# Использование переменой: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Когда вы используете переменную - присваиваете, экспортируете и т.д. - +# пишите её имя без $. А для получения значения переменной используйте $. +# Заметьте, что ' (одинарные кавычки) не раскрывают переменные в них. + +# Подстановка строк в переменные +echo ${VARIABLE/Просто/A} +# Это выражение заменит первую встреченную подстроку "Просто" на "A" + +# Взять подстроку из переменной +LENGTH=7 +echo ${VARIABLE:0:LENGTH} +# Это выражение вернет только первые 7 символов переменной VARIABLE + +# Значение по умолчанию +echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"} +# Это сработает при отсутствующем значении (FOO=) и пустой строке (FOO=""); +# ноль (FOO=0) вернет 0. +# Заметьте, что в любом случае значение самой переменной FOO не изменится. + +# Встроенные переменные: +# В bash есть полезные встроенные переменные, например +echo "Последнее возвращенное значение: $?" +echo "PID скрипта: $$" +echo "Количество аргументов: $#" +echo "Аргументы скрипта: $@" +echo "Аргументы скрипта, распределённые по отдельным переменным: $1 $2..." + +# Чтение аргументов из устройста ввода: +echo "Как Вас зовут?" +read NAME # Обратите внимание, что нам не нужно определять новую переменную +echo Привет, $NAME! + +# У нас есть обычная структура if: +# наберите 'man test' для получения подробной информации о форматах условия +if [ $NAME -ne $USER ] +then + echo "Имя не совпадает с именем пользователя" +else + echo "Имя совпадает с именем пользователя" +fi + +# Также есть условное исполнение +echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой" +echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно" + +# Можно использовать && и || в выражениях if, когда нужно несколько пар скобок: +if [ $NAME == "Steve" ] && [ $AGE -eq 15 ] +then + echo "Исполнится, если $NAME равно Steve И $AGE равно 15." +fi + +if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ] +then + echo "Исполнится, если $NAME равно Daniya ИЛИ Zach." +fi + +# Выражения обозначаются таким форматом: +echo $(( 10 + 5 )) + +# В отличие от других языков программирования, Bash - это командная оболочка, +# а значит, работает в контексте текущей директории. +# Вы можете просматривать файлы и директории в текущей директории командой ls: +ls + +# У этой команды есть опции: +ls -l # Показать каждый файл и директорию на отдельной строке + +# Результат предыдущей команды может быть направлен на вход следующей. +# Команда grep фильтрует ввод по шаблону. +# Так мы можем просмотреть только *.txt файлы в текущей директории: +ls -l | grep "\.txt" + +# Вы можете перенаправить ввод и вывод команды (stdin, stdout и stderr). +# Следующая команда означает: читать из stdin, пока не встретится ^EOF$, и +# перезаписать hello.py следующим строками (до строки "EOF"): +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Запуск hello.py с разными вариантами перенаправления потоков +# стандартных ввода, вывода и ошибок: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# Поток ошибок перезапишет файл, если этот файл существует, +# поэтому, если вы хотите дописывать файл, используйте ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Переписать output.txt, дописать error.err и сосчитать строки: +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Запустить команду и вывести ее файловый дескриптор (смотрите: man fd) +echo <(echo "#helloworld") + +# Перезаписать output.txt строкой "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим) +rm -v output.out error.err output-and-error.log + +# Команды могут быть подставлены в строку с помощью $( ): +# следующие команды выводят число файлов и директорий в текущей директории. +echo "Здесь $(ls | wc -l) элементов." + +# То же самое можно сделать с использованием обратных кавычек, +# но они не могут быть вложенными, поэтому предпочтительно использовать $( ). +echo "Здесь `ls | wc -l` элементов." + +# В Bash есть структура case, которая похожа на switch в Java и C++: +case "$VARIABLE" in + # Перечислите шаблоны для условий, которые хотите отловить + 0) echo "Тут ноль.";; + 1) echo "Тут один.";; + *) echo "Это не пустое значение.";; +esac + +# Цикл for перебирает элементы переданные в аргументе: +# Содержимое $VARIABLE будет напечатано три раза. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# Или с использованием "традиционного" синтаксиса цикла for: +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Цикл for можно использовать для действий с файлами. +# Запустим команду 'cat' для файлов file1 и file2 +for VARIABLE in file1 file2 +do + cat "$VARIABLE" +done + +# ... или выводом из команд +# Запустим cat для вывода из ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# Цикл while: +while [ true ] +do + echo "тело цикла здесь..." + break +done + +# Вы можете определять функции +# Определение: +function foo () +{ + echo "Аргументы работают также, как аргументы скрипта: $@" + echo "и: $1 $2..." + echo "Это функция" + return 0 +} + +# или просто +bar () +{ + echo "Другой способ определить функцию!" + return 0 +} + +# Вызов функции +foo "Мое имя" $NAME + +# Есть много полезных команд, которые нужно знать: +# напечатать последние 10 строк файла file.txt +tail -n 10 file.txt +# напечатать первые 10 строк файла file.txt +head -n 10 file.txt +# отсортировать строки file.txt +sort file.txt +# отобрать или наоборот пропустить повторяющиеся строки (с опцией -d отбирает) +uniq -d file.txt +# напечатать только первую колонку перед символом ',' +cut -d ',' -f 1 file.txt +# заменить каждое 'okay' на 'great' в файле file.txt (regex поддерживается) +sed -i 's/okay/great/g' file.txt +# вывести в stdout все строки из file.txt, совпадающие с шаблоном regex; +# этот пример выводит строки, которые начинаются на "foo" и оканчиваются "bar" +grep "^foo.*bar$" file.txt +# передайте опцию -c чтобы вывести число строк, в которых совпал шаблон +grep -c "^foo.*bar$" file.txt +# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F) +fgrep "^foo.*bar$" file.txt + +# Читайте встроенную документацию оболочки Bash командой 'help': +help +help help +help for +help return +help source +help . + +# Читайте Bash man-документацию +apropos bash +man 1 bash +man bash + +# Читайте документацию info (? для помощи) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Читайте bash info документацию: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/ru-ru/brainfuck-ru.html.markdown b/ru-ru/brainfuck-ru.html.markdown new file mode 100644 index 00000000..fcee185f --- /dev/null +++ b/ru-ru/brainfuck-ru.html.markdown @@ -0,0 +1,85 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +Brainfuck (пишется маленькими буквами, кроме начала предложения) - это очень +маленький Тьюринг-полный язык программирования лишь с 8 командами. + +Вы можете испытать brainfuck в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/). + +``` +Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек. + +Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями, +и указателем с позицией в текущей ячейке. + +Всего восемь команд: ++ : Увеличивает значение на единицу в текущей ячейке. +- : Уменьшает значение на единицу в текущей ячейке. +> : Смещает указатель данных на следующую ячейку (ячейку справа). +< : Смещает указатель данных на предыдущую ячейку (ячейку слева). +. : Печатает ASCII символ из текущей ячейки (напр. 65 = 'A'). +, : Записывает один входной символ в текущую ячейку. +[ : Если значение в текущей ячейке равно нулю, то пропустить все команды + до соответствующей ] . В противном случае, перейти к следующей инструкции. +] : Если значение в текущей ячейке равно нулю, то перейти к следующей инструкции. + В противном случае, вернуться назад к соответствующей [ . + +[ и ] образуют цикл while. Естественно, они должны быть сбалансированы. + +Давайте рассмотрим некоторые базовые brainfuck-программы. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Эта программа выводит букву 'A'. Сначала программа увеличивает значение +ячейки №1 до 6. Ячейка №1 будет использоваться циклом. Затем программа входит +в цикл ([) и переходит к ячейке №2. Ячейка №2 увеличивается до 10, переходим +назад к ячейке №1 и уменьшаем ячейку №1. Этот цикл проходит 6 раз (ячейка №1 +уменьшается до нуля, и с этого места пропускает инструкции до соответствующей ] +и идет дальше). + +В этот момент мы находимся в ячейке №1, которая имеет значение 0, значение +ячейки №2 пока 60. Мы переходим на ячейку №2, увеличиваем 5 раз, до значения 65, +и затем выводим значение ячейки №2. Код 65 является символом 'A' в кодировке ASCII, +так что 'A' выводится на терминал. + + +, [ > + < - ] > . + +Данная программа считывает символ из пользовательского ввода и копирует символ +в ячейку №1. Затем мы начинаем цикл. Переходим к ячейке №2, увеличиваем значение +ячейки №2, идем назад к ячейке №1 и уменьшаем значение ячейки №1. Это продолжается +до тех пор, пока ячейка №1 не равна 0, а ячейка №2 сохраняет старое значение +ячейки №1. Мы завершаем цикл на ячейке №1, поэтому переходим в ячейку №2 и +затем выводим символ ASCII. + +Также имейте в виду, что пробелы здесь исключительно для читабельности. Вы можете +легко написать и так: + +,[>+<-]>. + +Попытайтесь разгадать, что следующая программа делает: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Программа принимает два числа на вход и умножает их. + +Суть в том, что программа сначала читает два ввода. Затем начинается внешний цикл, +сохраняя ячейку №1. Затем программа перемещается в ячейку №2, и начинается +внутренний цикл с сохранением ячейки №2, увеличивая ячейку №3. Однако появляется +проблема: В конце внутреннего цикла ячейка №2 равна нулю. В этом случае, +внутренний цикл не будет работать уже в следующий раз. Чтобы решить эту проблему, +мы также увеличим ячейку №4, а затем копируем ячейку №4 в ячейку №2. +Итак, ячейка №3 - результат. +``` + +Это и есть brainfuck. Не так уж сложно, правда? Забавы ради, вы можете написать +свою собственную brainfuck-программу или интерпретатор на другом языке. +Интерпретатор достаточно легко реализовать, но если вы мазохист, попробуйте +написать brainfuck-интерпретатор... на языке brainfuck. diff --git a/ru-ru/c-ru.html.markdown b/ru-ru/c-ru.html.markdown new file mode 100644 index 00000000..5988b159 --- /dev/null +++ b/ru-ru/c-ru.html.markdown @@ -0,0 +1,483 @@ +--- +language: c +filename: learnc-ru.c +contributors: + - ["Adam Bard", "http://adambard.com/"] + - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] +translators: + - ["Evlogy Sutormin", "http://evlogii.com"] +lang: ru-ru +--- + +Что ж, Си всё ещё является лидером среди современных высокопроизводительных языков. + +Для большинствоа программистов, Си – это самый низкоуровневый язык на котором они когда-либо писали, +но этот язык даёт больше, чем просто повышение производительности. +Держите это руководство в памяти и вы сможете использовать Си максимально эффективно. + +```c +// Однострочный комментарий начинается с // - доступен только после С99. + +/* +Многострочный комментарий выглядит так. Работает начиная с С89. +*/ + +// Импорт файлов происходит с помощью **#include** +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// Файлы <в угловых скобочках> будут подключаться из стандартной библиотеки. +// Свои файлы необходимо подключать с помощью "двойных кавычек". +#include "my_header.h" + +// Объявление функций должно происходить в .h файлах или вверху .c файла. +void function_1(); +void function_2(); + +// Точка входа в программу – это функция main. +int main() { + // для форматированного вывода в консоль используется printf + // %d – означает, что будем выводить целое число, \n переводит указатель вывода + // на новую строчку + printf("%d\n", 0); // => напечатает "0" + // Каждый оператор заканчивается точкой с запятой. + + /////////////////////////////////////// + // Типы + /////////////////////////////////////// + + // int обычно имеет длину 4 байта + int x_int = 0; + + // short обычно имеет длину 2 байта + short x_short = 0; + + // char гарантированно имеет длину 1 байта + char x_char = 0; + char y_char = 'y'; // Символьные литералы заключаются в кавычки '' + + // long как правило занимает от 4 до 8 байт + // long long занимает как минимум 64 бита + long x_long = 0; + long long x_long_long = 0; + + // float это 32-битное число с плавающей точкой + float x_float = 0.0; + + // double это 64-битное число с плавающей точкой + double x_double = 0.0; + + // Целые типы могут быть беззнаковыми. + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // sizeof(T) возвращает размер переменной типа Т в байтах. + // sizeof(obj) возвращает размер объекта obj в байтах. + printf("%zu\n", sizeof(int)); // => 4 (на большинстве машин int занимает 4 байта) + + // Если аргуметом sizeof будет выражение, то этот аргумент вычисляется + // ещё во время компиляции кода (кроме динамических массивов). + int a = 1; + // size_t это беззнаковый целый тип который использует как минимум 2 байта + // для записи размера объекта + size_t size = sizeof(a++); // a++ не выполнится + printf("sizeof(a++) = %zu, где a = %d\n", size, a); + // выведет строку "sizeof(a++) = 4, где a = 1" (на 32-битной архитектуре) + + // Можно задать размер массива при объявлении. + char my_char_array[20]; // Этот массив занимает 1 * 20 = 20 байт + int my_int_array[20]; // Этот массив занимает 4 * 20 = 80 байт (сумма 4-битных слов) + + // Можно обнулить массив при объявлении. + char my_array[20] = {0}; + + // Индексация массива происходит также как и в других Си-подобных языках. + my_array[0]; // => 0 + + // Массивы изменяемы. Это просто память как и другие переменные. + my_array[1] = 2; + printf("%d\n", my_array[1]); // => 2 + + // В C99 (а также опционально в C11), массив может быть объявлен динамически. + // Размер массива не обязательно должен быть рассчитан на этапе компиляции. + printf("Enter the array size: "); // спрашиваем юзера размер массива + char buf[0x100]; + fgets(buf, sizeof buf, stdin); + size_t size = strtoul(buf, NULL, 10); // strtoul парсит строку в беззнаковое целое + int var_length_array[size]; // объявление динамического массива + printf("sizeof array = %zu\n", sizeof var_length_array); + // Вывод программы (в зависимости от архитектуры) будет таким: + // > Enter the array size: 10 + // > sizeof array = 40 + + // Строка – это просто массив символов, оканчивающийся нулевым (NUL (0x00)) байтом + // представляемым в строке специальным символом '\0'. + // Нам не нужно вставлять нулевой байт в строковой литерал, + // компилятор всё сделает за нас. + char a_string[20] = "This is a string"; + printf("%s\n", a_string); // %s обозначает вывод строки + + printf("%d\n", a_string[16]); // => 0 + // байт #17 тоже равен 0 (а также 18, 19, и 20) + + // Если между одинарными кавычками есть символ – это символьный литерал, + // но это тип int, а не char (по историческим причинам). + + int cha = 'a'; // хорошо + char chb = 'a'; // тоже хорошо (подразумевается преобразование int в char) + + /////////////////////////////////////// + // Операторы + /////////////////////////////////////// + + // Можно использовать множественное объявление. + int i1 = 1, i2 = 2; + float f1 = 1.0, f2 = 2.0; + + // Арифметика обычная + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5, но обрезается до 0) + + f1 / f2; // => 0.5, плюс-минус погрешность потому что, + // цифры с плавающей точкой вычисляются неточно! + + // Модуль + 11 % 3; // => 2 + + // Операции сравнения вам уже знакомы, но в Си нет булевого типа. + // Вместо него используется int. 0 это false, всё остальное это true. + // Операции сравнения всегда возвращают 1 или 0. + 3 == 2; // => 0 (false) + 3 != 2; // => 1 (true) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // Си это не Питон – операции сравнения могут быть только парными. + int a = 1; + // ОШИБКА: + int between_0_and_2 = 0 < a < 2; + // Правильно: + int between_0_and_2 = 0 < a && a < 2; + + // Логика + !3; // => 0 (логическое НЕ) + !0; // => 1 + 1 && 1; // => 1 (логическое И) + 0 && 1; // => 0 + 0 || 1; // => 1 (лигическое ИЛИ) + 0 || 0; // => 0 + + // Битовые операторы + ~0x0F; // => 0xF0 (побитовое отрицание) + 0x0F & 0xF0; // => 0x00 (побитовое И) + 0x0F | 0xF0; // => 0xFF (побитовое ИЛИ) + 0x04 ^ 0x0F; // => 0x0B (исключающее ИЛИ (XOR)) + 0x01 << 1; // => 0x02 (побитовый сдвиг влево (на 1)) + 0x02 >> 1; // => 0x01 (побитовый сдвиг вправо (на 1)) + + // Будьте осторожны при сдвиге беззнакового int, эти операции не определены: + // - сдвиг в знаковый бит у целого числа (int a = 1 << 32) + // - сдвиг влево отрицательных чисел (int a = -1 << 2) + + /////////////////////////////////////// + // Структуры ветвления + /////////////////////////////////////// + + // Условный оператор + if (0) { + printf("I am never run\n"); + } else if (0) { + printf("I am also never run\n"); + } else { + printf("I print\n"); + } + + // Цикл с предусловием + int ii = 0; + while (ii < 10) { + printf("%d, ", ii++); // инкрементация происходит после того как + // знаечние ii передано ("postincrement") + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + //Цикл с постусловием + int kk = 0; + do { + printf("%d, ", kk); + } while (++kk < 10); // инкрементация происходит перед тем как + // передаётся знаечние kk ("preincrement") + // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Цикл со счётчиком + int jj; + for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Ветвление с множественным выбором + switch (some_integral_expression) { + case 0: // значения должны быть целыми константами (и могут быть выражениями) + do_stuff(); + break; // если не написать break; то управление будет передено следующему блоку + case 1: + do_something_else(); + break; + default: + // если не было совпадения, то выполняется блок default: + fputs("ошибка!\n", stderr); + exit(-1); + break; + } + + /////////////////////////////////////// + // Форматирование вывода + /////////////////////////////////////// + + // Каждое выражение в Си имеет тип, но вы можете привести один тип к другому, + // если хотите (с некоторыми искажениями). + + int x_hex = 0x01; // Вы можете назначать переменные с помощью шеснадцатеричного кода. + + // Приведение типов будет пытаться сохранять цифровые значения. + printf("%d\n", x_hex); // => Prints 1 + printf("%d\n", (short) x_hex); // => Prints 1 + printf("%d\n", (char) x_hex); // => Prints 1 + + // Типы могут переполняться без вызова предупреждения. + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 if char is 8 bits long) + + // Для определения максимального значения типов `char`, `signed char` и `unisigned char`, + // соответственно используйте CHAR_MAX, SCHAR_MAX и UCHAR_MAX макросы из <limits.h> + + // Целые типы могут быть приведены к вещественным и наоборот. + printf("%f\n", (float)100); // %f formats a float + printf("%lf\n", (double)100); // %lf formats a double + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // Указатели + /////////////////////////////////////// + + // Указатель – это переменная которая хранит адрес в памяти. + // При объявлении указателя указывается тип данных переменной на которую он будет ссылаться. + // Вы можете получить адрес любой переменной, а потом работать с ним. + + // Используйте & для получения адреса переменной. + int x = 0; + printf("%p\n", (void *)&x); // => Напечатает адрес в памяти, где лежит переменная x + // (%p выводит указатель на void *) + + // Для объявления указателя нужно поставить * перед именем. + int *px, not_a_pointer; // px это указатель на int + px = &x; // сохранит адрес x в px + printf("%p\n", (void *)px); // => Напечатает адрес в памяти, где лежит переменная px + printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer)); + // => Напечатает "8, 4" в 64 битной системе + + // Для того, чтобы получить знаечние по адресу, напечатайте * перед именем. + // Да, использование * при объявлении указателя и получении значения по адресу + // немного запутано, но вы привыкнете. + printf("%d\n", *px); // => Напечаатет 0, значение перемененной x + + // Вы также можете изменять значение, на которое указывает указатель. + (*px)++; // Инкрементирует значение на которое указывает px на единицу + printf("%d\n", *px); // => Напечатает 1 + printf("%d\n", x); // => Напечатает 1 + + // Массивы удобно использовать для болшого количества однотипных данных. + int x_array[20]; + int xx; + for (xx = 0; xx < 20; xx++) { + x_array[xx] = 20 - xx; + } // Объявление x_array с значениями 20, 19, 18,... 2, 1 + + // Объявление указателя на int с адресом массива. + int* x_ptr = x_array; + // x_ptr сейчас указывает на первый элемент массива (со значением 20). + // Это рабоатет, потому что имя массива возвращает указатель на первый элемент. + // Например, когда массив передаётся в функцию или назначается указателю, он + // невявно преобразуется в указатель. + // Исключения: когда массив является аргументом для оператор '&': + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr не является 'int *'! + // он является "указателем на массив" (из десяти 'int'ов). + // или когда массив это строчный литерал, используемый при объявлении массива символов: + char arr[] = "foobarbazquirk"; + // или когда массив является аргументом `sizeof` или `alignof` операторов: + int arr[10]; + int *ptr = arr; // то же самое что и "int *ptr = &arr[0];" + printf("%zu %zu\n", sizeof arr, sizeof ptr); // напечатает "40, 4" или "40, 8" + + // Декрементация и инкрементация указателей зависит от их типа + // (это называется арифметика указателей) + printf("%d\n", *(x_ptr + 1)); // => Напечатает 19 + printf("%d\n", x_array[1]); // => Напечатает 19 + + // Вы также можете динамически выделять несколько блоков памяти с помощью + // функции malloc из стандартной библиотеки, которая принимает один + // аргумент типа size_t – количество байт необходимых для выделения. + int *my_ptr = malloc(sizeof(*my_ptr) * 20); + for (xx = 0; xx < 20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx + } // Выделяет память для 20, 19, 18, 17... 2, 1 (как int'ы) + + // Работа с памятью с помощью указателей может давать неожиданные и + // непредсказуемые результаты. + printf("%d\n", *(my_ptr + 21)); // => Напечатает кто-нибудь-знает-что? + // Скорей всего программа вылетит. + + // Когда вы закончили работать с памятью, которую ранее выделили, вам необходимо + // освободить её, иначе это может вызвать утечку памяти или ошибки. + free(my_ptr); + + // Строки это массивы символов, но обычно они представляются как + // указатели на символ (как указатели на первый элемент массива). + // Хорошей практикой считается использование `const char *' при объявлении + // строчного литерала. При таком подходе литерал не может быть изменён. + // (например "foo"[0] = 'a' вызовет ошибку!) + + const char *my_str = "This is my very own string literal"; + printf("%c\n", *my_str); // => 'T' + + // Это не работает, если строка является массивом + // (потенциально задаваемой с помощью строкового литерала) + // который находиться в перезаписываемой части памяти: + + char foo[] = "foo"; + foo[0] = 'a'; // это выполнится и строка теперь "aoo" + + void function_1() +} // конец функции main() + +/////////////////////////////////////// +// Функции +/////////////////////////////////////// + +// Синтаксис объявления функции: +// <возвращаемый тип> <имя функции>(аргументы) + +int add_two_ints(int x1, int x2) { + return x1 + x2; // Используйте return для возврата значения +} + +/* +Данные в функцию передаются "по значению", но никто не мешает +вам передавать в функцию указатели и менять данные по указателям. + +Например: инвертировать строку прямо в функции +*/ + +// void означает, что функция ничего не возвращает +void str_reverse(char *str_in) { + char tmp; + int ii = 0; + size_t len = strlen(str_in); // `strlen()` является частью стандартной библиотеки + for (ii = 0; ii < len / 2; ii++) { + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // ii-тый символ с конца + str_in[len - ii - 1] = tmp; + } +} + +char c[] = "This is a test."; +str_reverse(c); +printf("%s\n", c); // => Выведет ".tset a si sihT" + +/////////////////////////////////////// +// Типы и структуры определяемые пользователем +/////////////////////////////////////// + +// typedef используется для задания стандартным типам своих названий +typedef int my_type; +my_type my_type_var = 0; + +// Структуры это просто коллекция данных, память выделяется последовательно, +// в том порядке в котором записаны данные. +struct rectangle { + int width; + int height; +}; + +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) – не всегда верно +// из-за особенностей компиляции (необычное поведение при отступах)[1]. + +void function_1() { + struct rectangle my_rec; + + // Доступ к структурам через точку + my_rec.width = 10; + my_rec.height = 20; + + // Вы можете объявить указатель на структуру + struct rectangle *my_rec_ptr = &my_rec; + + // Можно доступаться к структуре и через указатель + (*my_rec_ptr).width = 30; + + // ... или ещё лучше: используйте оператор -> для лучшей читабельночти + my_rec_ptr->height = 10; // то же что и "(*my_rec_ptr).height = 10;" +} + +// Вы можете применить typedef к структуре, для удобства. +typedef struct rectangle rect; + +int area(rect r) { + return r.width * r.height; +} + +// Если вы имеете большую структуру, можно доступаться к ней "по указателю", +// чтобы избежать копирования всей структуры. +int area(const rect *r) { + return r->width * r->height; +} + +/////////////////////////////////////// +// Указатели на функции +/////////////////////////////////////// + +/* +Во время исполнения функции находятся по известным адресам в памяти. +Указатель на функцию может быть использован для непосредственного вызова функции. +Однако синтаксис может сбивать с толку. + +Пример: использование str_reverse по указателю +*/ + +void str_reverse_through_pointer(char *str_in) { + // Определение функции через указатель. + void (*f)(char *); // Сигнатура должна полность совпадать с целевой функцией. + f = &str_reverse; // Присвоить фактический адрес (во время исполнения) + // "f = str_reverse;" тоже будет работать. + //Имя функции (как и массива) возвращает указатель на начало. + (*f)(str_in); // Просто вызываем функцию через указатель. + // "f(str_in);" или вот так +} +``` + +## На почитать + +Лучше всего найдите копию [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language) +Это **книга** написанная создателями Си. Но будьте осторожны, она содержит идеи которые больше не считаются хорошими. + +Другой хороший ресурс: [Learn C the hard way](http://c.learncodethehardway.org/book/). + +Если у вас появился вопрос, почитайте [compl.lang.c Frequently Asked Questions](http://c-faq.com). + +Очень важно использовать правильные отступы и ставить пробелы в нужных местах. +Читаемый код лучше чем красивый или быстрый код. +Чтобы научиться писать хороший код, почитайте [Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle). + +Также не забывайте, что [Google](http://google.com) и [Яндекс](http://yandex.ru) – ваши хорошие друзья. + +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member diff --git a/ru-ru/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown new file mode 100644 index 00000000..2f508a00 --- /dev/null +++ b/ru-ru/clojure-ru.html.markdown @@ -0,0 +1,427 @@ +--- +language: clojure +filename: learnclojure-ru.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Alexey Pirogov", "http://twitter.com/alex_pir"] +lang: ru-ru +--- + +Clojure, это представитель семейства Lisp-подобных языков, разработанный +для Java Virtual Machine. Язык идейно гораздо ближе к чистому +[функциональному программированию](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) чем его прародитель Common Lisp, но в то же время обладает набором инструментов для работы с состоянием, +таких как [STM](https://ru.wikipedia.org/wiki/Software_transactional_memory). + +Благодаря такому сочетанию технологий в одном языке, разработка программ, +предполагающих конкурентное выполнение, значительно упрощается +и даже может быть автоматизирована. + +(Последующие примеры кода предполагают выполнение в Clojure версии 1.2 и выше) + + +```clojure +; Комментарии начинаются символом ";". + +; Код на языке Clojure записывается в виде "форм", +; которые представляют собой обычные списки элементов, разделенных пробелами, +; заключённые в круглые скобки +; +; Clojure Reader (инструмент языка, отвечающий за чтение исходного кода), +; анализируя форму, предполагает, что первым элементом формы (т.е. списка) +; является функция или макрос, который следует вызвать, передав ему +; в качестве аргументов остальные элементы списка-формы. + +; Первым вызовом в файле должен быть вызов функции ns, +; которая отвечает за выбор текущего пространства имен (namespace) +(ns learnclojure-ru) + +; Несколько простых примеров: + +; str объединяет в единую строку все свои аргументы +(str "Hello" " " "World") ; => "Hello World" + +; Арифметика тоже выглядит несложно +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; Проверка на равенство (Equality) +(= 1 1) ; => true +(= 2 1) ; => false + +; Для булевой логики вам может понадобиться not +(not true) ; => false + +; Вложенные формы, конечно же, допустимы и работают вполне предсказуемо +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; Типы +;;;;;;;;;;;;; + +; Clojure использует типы Java для представления булевых значений, +; строк и чисел +; Узнать тип мы можем, использую функцию `class +(class 1) ; Целочисленные литералы типа по-умолчанию являются java.lang.Long +(class 1.) ; Числа с плавающей точкой, это java.lang.Double +(class "") ; Строки всегда заключаются в двойные кавычки + ; и представляют собой java.lang.String +(class false) ; Булевы значения, это экземпляры java.lang.Boolean +(class nil) ; "Пустое" значение называется "nil" + +; Если Вы захотите создать список из чисел, вы можете просто +; предварить форму списка символом "'", который подскажет Reader`у, +; что эта форма не требует вычисления +'(+ 1 2) ; => (+ 1 2) +; ("'", это краткая запись формы (quote (+ 1 2)) + +; "Квотированный" список можно вычислить, передав его функции eval +(eval '(+ 1 2)) ; => 3 + +; Коллекции и Последовательности +;;;;;;;;;;;;;;;;;;; + +; Списки (Lists) в clojure структурно представляют собой "связанные списки", +; тогда как Векторы (Vectors), устроены как массивы. +; Векторы и Списки тоже являются классами Java! +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; Список может быть записан, как (1 2 3), но в этом случае +; он будет воспринят reader`ом, как вызов функции. +; Есть два способа этого избежать: +; '(1 2 3) - квотирование, +; (list 1 2 3) - явное конструирование списка с помощью функции list. + +; "Коллекции", это некие наборы данных +; И списки, и векторы являются коллекциями: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; "Последовательности" (seqs), это абстракция над наборами данных, +; элементы которых "упакованы" последовательно. +; Списки - последовательности, а вектора - нет. +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; Любая seq предоставляет доступ только к началу последовательности данных, +; не предоставляя информацию о её длине. +; При этом последовательности могут быть и бесконечными, +; т.к. являются ленивыми и предоставляют данные только по требованию! +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (бесконечная последовательность!) +(take 4 (range)) ; (0 1 2 3) + +; Добавить элемент в начало списка или вектора можно с помощью функции cons +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; Функция conj добавляет элемент в коллекцию +; максимально эффективным для неё способом. +; Для списков эффективно добавление в начло, а для векторов - в конец. +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; Функция concat объединяет несколько списков и векторов в единый список +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; Работать с коллекциями удобно с помощью функций filter и map +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; reduce поможет "свернуть" коллекцию +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; Вызывая reduce, мы можем указать начальное значение +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; Функции +;;;;;;;;;;;;;;;;;;;;; + +; Функция создается специальной формой fn. +; "Тело"" функции может состоять из нескольких форм, +; но результатом вызова функции всегда будет результат вычисления +; последней из них. +(fn [] "Hello World") ; => fn + +; (Вызов функции требует "оборачивания" fn-формы в форму вызова) +((fn [] "Hello World")) ; => "Hello World" + +; Назначить значению имя можно специальной формой def +(def x 1) +x ; => 1 + +; Назначить имя можно любому значению, в т.ч. и функции: +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; Поскольку именование функций - очень частая операция, +; clojure позволяет, сделать это проще: +(defn hello-world [] "Hello World") + +; Вектор [] в форме описания функции, следующий сразу за именем, +; описывает параметры функции: +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; Одна функция может иметь сразу несколько наборов аргументов: +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; Также функция может иметь набор аргументов переменной длины +(defn count-args [& args] ; args будет содержать seq аргументов + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" + +; Можно комбинировать оба подхода задания аргументов +(defn hello-count [name & args] + (str "Hello " name ", you passed " (count args) " extra args")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" + +; Для создания анонимных функций есть специальный синтаксис: +; функциональные литералы +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; такие функциональные литералы удобно использовать с map, filter и reduce +(map #(* 10 %1) [1 2 3 5]) ; => (10 20 30 50) +(filter #(> %1 3) [1 2 3 4 5 6 7]) ; => (4 5 6 7) +(reduce #(str %1 "," %2) [1 2 3 4]) ; => "1,2,3,4" + +; Отображения (Maps) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; Hash maps и array maps имеют одинаковый интерфейс. +; Hash maps производят поиск по ключу быстрее, но не сохраняют порядок ключей +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; Array maps автоматически преобразуются в hash maps, +; как только разрастутся до определенного размера + +; Отображения могут использовать в качестве ключей любые хэшируемые значения, +; однако предпочтительными являются ключи, +; являющиеся "ключевыми словами" (keywords) +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; Предыдущий пример содержит запятые в коде, однако reader не использует их, +; при обработке литералов - запятые просто воспринимаются, +; как "пробельные символы" (whitespaces) + +; Отображение может выступать в роли функции, возвращающей значение по ключу +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; При попытке получить отсутствующее значение, будет возвращён nil +(stringmap "d") ; => nil + +; Иногда бывает удобно указать конкретное значение по-умолчанию: +({:a 1 :b 2} :c "Oops!") ; => "Oops!" + +; Keywords тоже могут использоваться в роли функций! +(:b keymap) ; => 2 + +; Однако этот фокус не пройдёт со строками. +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; Добавить пару ключ-значение в отображение можно функцией assoc +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; Но всегда следует помнить, что значения в Clojure - неизменяемые! +keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут + +; dissoc позволяет исключить значение по ключу +(dissoc keymap :a :b) ; => {:c 3} + +; Множества (Sets) +;;;;;;;;;;;;;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; Добавляются элементы посредством conj +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; Исключаются - посредством disj +(disj #{1 2 3} 1) ; => #{2 3} + +; Вызов множества, как функции, позволяет проверить +; принадлежность элемента этому множеству: +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; В пространстве имен clojure.sets +; содержится множество функций для работы с множествами + +; Полезные формы +;;;;;;;;;;;;;;;;; + +; Конструкции ветвления в clojure, это обычные макросы +; и подобны их собратьям в других языках: +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; Специальная форма let позволяет присвоить имена значениям локально. +; При этом все изменения будут видны только вложенным формам: +(def a 10) +(let [a 1 b 2] + (> a b)) ; => false + +; Несколько форм можно объединить в одну форму посредством do +; Значением do-формы будет значение последней формы из списка вложенных в неё: +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; Множество макросов содержит внутри себя неявную do-форму. +; Пример - макрос определения функции: +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; Ещё один пример - let: +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; Модули +;;;;;;;;; + +; Форма "use" позволяет добавить в текущее пространство имен +; все имена (вместе со значениями) из указанного модуля: +(use 'clojure.set) + +; Теперь нам доступны операции над множествами: +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; use позволяет указать, какие конкретно имена +; должны быть импортированы из модуля: +(use '[clojure.set :only [intersection]]) + +; Также модуль может быть импортирован формой require +(require 'clojure.string) + +; После этого модуль становится доступе в текущем пространстве имен, +; а вызов его функций может быть осуществлен указанием полного имени функции: +(clojure.string/blank? "") ; => true + +; Импортируемому модулю можно назначить короткое имя: +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (Литерал вида #"" обозначает регулярное выражение) + +; Вместо отдельной формы require (и use, хотя это и не приветствуется) можно +; указать необходимые модули прямо в форме ns: +(ns test + (:require + [clojure.string :as str] ; Внимание: при указании внутри формы ns + [clojure.set :as set])) ; имена пакетов не квотируются! + +; Java +;;;;;;; + +; Стандартная библиотека Java очень богата, +; и всё это богатство доступно и для Clojure! + +; import позволяет импортировать модули Java +(import java.util.Date) + +; В том числе и из ns +(ns test + (:import java.util.Date + java.util.Calendar)) + +; Имя класса, сопровождаемое символом "." позволяет +; инстанцировать объекты Java-классов: +(Date.) ; <a date object> + +; форма . позволяет вызывать методы: +(. (Date.) getTime) ; <a timestamp> +(.getTime (Date.)) ; а можно и так + +; Статические методы вызываются как функции модуля: +(System/currentTimeMillis) ; <a timestamp> (Модуль system всегда доступен!) + +; doto позволяет удобно работать с объектами, изменяющими свое состояние +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; Работа с изменяемым сотоянием +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; Clojure предоставляет набор инструментов +; для работы с изменяемым состоянием: Software Transactional Memory. +; Структуры STM представлены тремя типами: +; - атомы (atoms) +; - агенты (agents) +; - ссылки (references) + +; Самые простые хранители состояния - атомы: +(def my-atom (atom {})) ; {} - начальное состояние атома + +; Обновляется атом посредством swap!. +; swap! применяет функцию аргумент к текущему значению +; атома и помещает в атом результат +(swap! my-atom assoc :a 1) ; Обновляет my-atom, помещая в него (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Обновляет my-atom, помещая в него (assoc {:a 1} :b 2) + +; Получить значение атома можно посредством '@' +; (провести так называемую операцию dereference) +my-atom ;=> Atom<#...> (Возвращает объект типа Atom) +@my-atom ; => {:a 1 :b 2} + +; Пример реализации счётчика на атоме +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; С другими STM-конструкциями - refs и agents - можно ознакомиться тут: +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### Для будущего чтения + +Это руководство не претендует на полноту, но мы смеем надеяться, способно вызвать интерес к дальнейшему изучению языка. + +Clojure.org - сайт содержит большое количество статей по языку: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org - сайт документации языка с примерами использования функций: +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure - отличный способ закрепить навыки программирования на clojure, решая задачи вместе с коллегами со всего мира: +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org (да, именно) неплохой перечень статей для начинающих: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/ru-ru/coffeescript-ru.html.markdown b/ru-ru/coffeescript-ru.html.markdown new file mode 100644 index 00000000..f8416f38 --- /dev/null +++ b/ru-ru/coffeescript-ru.html.markdown @@ -0,0 +1,104 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["asaskevich", "http://github.com/asaskevich"] +filename: learncoffee-ru.coffee +lang: ru-ru +--- + +CoffeeScript - это небольшой язык, который компилируется один-в-один в эквивалентный код на языке JavaScript, а потому он не интерпретируется во время исполнения JavaScript кода. +Ключевой особенностью CoffeeScript является то, что он пытается создать читабельный, качественно оформленный и плавный JavaScript код, прекрасно работающий в любой среде JavaScript. + +Также загляните на официальный сайт [языка](http://coffeescript.org/), где можно найти весьма полное учебное пособие по CoffeeScript. + +```coffeescript +# CoffeeScript - язык хипстеров. +# Язык использует самое модное из множества современных языков. +# Эти комментарии по стилю похожи на комментарии Ruby или Python, они используют "решетку" в качестве знака комментария. + +### +Блоки комментариев выделяются тремя символами "решетки", в результирующем JavaScript коде они будут преобразованы в '/ * и '* /'. + +Перед тем, как идти далее, Вам нужно понимать семантику JavaScript. +### + +# Присвоение: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# Условия: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# Функции: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +fill = (container, liquid = "coffee") -> + "Заполняем #{container} жидкостью #{liquid}..." +#=>var fill; +# +#fill = function(container, liquid) { +# if (liquid == null) { +# liquid = "coffee"; +# } +# return "Заполняем " + container + " жидкостью " + liquid + "..."; +#}; + +# Списки и диапазоны: +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# Объекты: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Многоточия: +race = (winner, runners...) -> + print winner, runners +#=>race = function() { +# var runners, winner; +# winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(winner, runners); +#}; + +# Проверка на существование объекта: +alert "Так и знал!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Так и знал!"); } + +# Итерации по массивам: +cubes = (math.cube num for num in list) +#=>cubes = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +foods = ['broccoli', 'spinach', 'chocolate'] +eat food for food in foods when food isnt 'chocolate' +#=>foods = ['broccoli', 'spinach', 'chocolate']; +# +#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) { +# food = foods[_k]; +# if (food !== 'chocolate') { +# eat(food); +# } +#} +``` + +## На почитать + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) +- [CoffeeScript на русском](http://cidocs.ru/coffeescript/) diff --git a/ru-ru/erlang-ru.html.markdown b/ru-ru/erlang-ru.html.markdown new file mode 100644 index 00000000..99ea79ee --- /dev/null +++ b/ru-ru/erlang-ru.html.markdown @@ -0,0 +1,256 @@ +--- +language: erlang +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] +translators: + - ["Nikita Kalashnikov", "https://root.yuuzukiyo.net/"] +filename: learnerlang-ru.erl +lang: ru-ru +--- + +```erlang +% Символ процента предваряет однострочный комментарий. + +%% Два символа процента обычно используются для комментариев к функциям. + +%%% Три символа процента используются для комментариев к модулям. + +% Пунктуационные знаки, используемые в Erlang: +% Запятая (`,`) разделяет аргументы в вызовах функций, структурах данных и +% образцах. +% Точка (`.`) (с пробелом после них) разделяет функции и выражения в +% оболочке. +% Точка с запятой (`;`) разделяет выражения в следующих контекстах: +% формулы функций, выражения `case`, `if`, `try..catch` и `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Переменные и сопоставление с образцом. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Num = 42. % Все названия переменных начинаются с большой буквы. + +% Erlang использует единичное присваивание переменным. Если вы попытаетесь +% присвоить другое значение переменной `Num`, вы получите ошибку. +Num = 43. % ** exception error: no match of right hand side value 43 + +% В большинстве языков `=` обозначает операцию присвоения. В отличие от них, в +% Erlang `=` — операция сопоставления с образцом. `Lhs = Rhs` на самом +% деле подразумевает «вычисли правую часть выражения (Rhs) и затем сопоставь +% результат с образцом слева (Lhs)». +Num = 7 * 6. + +% Числа с плавающей точкой. +Pi = 3.14159. + +% Атомы используются для представления различных нечисловых констант. Названия +% атомов начинаются с буквы в нижнем регистре, за которой могут следовать другие +% буквы английского алфавита, цифры, символ подчёркивания (`_`) или «собака» +% (`@`). +Hello = hello. +OtherNode = example@node. + +% Если в имени атома нужно использовать другие символы, кроме допустимых, +% имя атома необходимо взять в одинарные кавычки (`'`). +AtomWithSpace = 'some atom with space'. + +% Кортежы подобны структурам в языке C. +Point = {point, 10, 45}. + +% Если нужно извлечь определённые данные из кортежа, используется оператор +% сопоставления с образцом — `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% Символ `_` может использоваться как «заполнитель» для переменных, значения +% которых в текущем выражении нас не интересуют. Он называется анонимной +% переменной. В отличие от остальных переменных, множественные использования +% `_` в одном образце не требуют, чтобы все значения, присваевыемые этой +% переменной, были идентичными. +Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. +{_, {_, {_, Who}, _}, _} = Person. % Who = joe + +% Список создаётся путём заключения его элементов в квадратные скобки и +% разделения их запятыми. Отдельные элементы списка могут быть любого типа. +% Первый элемент списка называется головой списка. Список, получающийся в +% результате отделения головы, называется хвостом списка. +ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. + +% Если `T` — список, то `[H|T]` — тоже список, где `H` является головой, а `T` — +% хвостом. Вертикальная черта (`|`) разделяет голову и хвост списка. +% `[]` — пустой список. +% Мы можем извлекать элементы из списка с помощью сопоставления с образцом. +% Если у нас есть непустой список `L`, тогда выражение `[X|Y] = L`, где `X` и +% `Y` — свободные (не связанные с другими значениям) переменные, извлечёт голову +% списка в `X` и его хвост в `Y`. +[FirstThing|OtherThingsToBuy] = ThingsToBuy. +% FirstThing = {apples, 10} +% OtherThingsToBuy = {pears, 6}, {milk, 3} + +% В Erlang нет строк как отдельного типа. Все используемые в программах строки +% являются обычным списком целых чисел. Строковые значения всегда должны быть в +% двойных кавычках (`"`). +Name = "Hello". +[72, 101, 108, 108, 111] = "Hello". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Последовательное программирование. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Модуль — основная единица кода в Erlang. В них пишутся и сохраняются все +% функции. Модули хранятся в файлах с расширением `.erl`. +% Модули должны быть скомпилированы перед тем, как использовать код из них. +% Скомпилированный файл модуля имеет разрешение `.beam`. +-module(geometry). +-export([area/1]). % список функций, экспортируемых из модуля. + +% Функция `area` состоит из двух формул (clauses). Формулы отделяются друг от +% друга точкой с запятой, после последнего определения должна стоять точка с +% пробелом после неё. +% Каждое определение имеет заголовок и тело. Заголовок состоит из названия +% функции и образца (в скобках); тело состоит из последовательных выражений, +% вычисляемых, когда аргументы функции совпадают с образцом в заголовке. +% Сопоставление с образцами в заголовках происходит в том порядке, в котором +% они перечислены в определении функции. +area({rectangle, Width, Ht}) -> Width * Ht; +area({circle, R}) -> 3.14159 * R * R. + +% Компиляция файла с исходным кодом geometry.erl. +c(geometry). % {ok,geometry} + +% Необходимо указывать имя модуля вместе с именем функции для определения, какую +% именно фукнцию мы хотим вызвать. +geometry:area({rectangle, 10, 5}). % 50 +geometry:area({circle, 1.4}). % 6.15752 + +% В Erlang две функции с разной арностью (числом аргументов) в пределах одного +% модуля представляются как две разные функции. +-module(lib_misc). +-export([sum/1]). % экспорт функции `sum` с арностью 1, принимающую один аргумент. +sum(L) -> sum(L, 0). +sum([], N) -> N; +sum([H|T], N) -> sum(T, H+N). + +% Fun'ы — анонимные функции, называемые так по причине отсутствия имени. Зато +% их можно присваивать переменным. +Double = fun(X) -> 2*X end. % `Double` указывает на анонимную функцию с идентификатором: #Fun<erl_eval.6.17052888> +Double(2). % 4 + +% Функции могут принимать fun'ы как параметры и возвращать их в качестве +% результата вычислений. +Mult = fun(Times) -> ( fun(X) -> X * Times end ) end. +Triple = Mult(3). +Triple(5). % 15 + +% Выделения списоков (list comprehensions) — выражения, создающие списки без +% применения анонимных функций, фильтров или map'ов. +% Запись `[F(X) || X <- L]` значит «список `F(X)`, где `X` последовательно +% выбирается из списка `L`». +L = [1,2,3,4,5]. +[2*X || X <- L]. % [2,4,6,8,10] +% В выделениях списков могут быть генераторы и фильтры для отделения подмножеств +% генерируемых значений. +EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% Охранные выражения используются для простых проверок переменных в образцах, +% что значительно расширяет возможности сопоставления. Они могут использоваться +% в заголовках определений функций, предварённые ключевым словом `when`, а также +% в условных конструкциях. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Охранные выражения можно группировать, разделяя запятой. +% Последовательность `GuardExpr1, GuardExpr2, ..., GuardExprN` является истинной +% только в том случае, когда все выражения, которые она содержат, являются +% истинными. +is_cat(A) when is_atom(A), A =:= cat -> true; +is_cat(A) -> false. +is_dog(A) when is_atom(A), A =:= dog -> true; +is_dog(A) -> false. + +% Последовательность охранных выражений, разделённых точками с запятой, является +% истинной в том случае, если хотя бы одно выражение из списка `G1; G2; ...; Gn` +% является истинным. +is_pet(A) when is_dog(A); is_cat(A) -> true; +is_pet(A) -> false. + +% Записи предоставляют возможность именования определённых элементов в кортежах. +% Определения записей могут быть включены в исходный код модулей Erlang или же +% в заголовочные файлы с расширением `.hrl`. +-record(todo, { + status = reminder, % Значение по умолчанию. + who = joe, + text +}). + +% Для чтения определений записей из файлов в оболочке можно использовать команду +% `rr`. +rr("records.hrl"). % [todo] + +% Создание и изменение записей. +X = #todo{}. +% #todo{status = reminder, who = joe, text = undefined} +X1 = #todo{status = urgent, text = "Fix errata in book"}. +% #todo{status = urgent, who = joe, text = "Fix errata in book"} +X2 = X1#todo{status = done}. +% #todo{status = done,who = joe,text = "Fix errata in book"} + +% Условное выражение `case`. +% Функция `filter` возвращет список всех элементов `X` из списка `L`, для +% которых выражение `P(X)` является истинным. +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% Условное выражение `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil; + end. + +% Внимание: в выражении `if` должно быть как минимум одно охранное выраженние, +% вычисляющееся в true, иначе возникнет исключение. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Обработка исключений. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Исключения возникают в случае внутренних ошибок системы или вызываются +% непосредственно из кода программы с помощью вызовов `throw(Exception)`, +% `exit(Exception)` или `erlang:error(Exception)`. +generate_exception(1) -> a; +generate_exception(2) -> throw(a); +generate_exception(3) -> exit(a); +generate_exception(4) -> {'EXIT', a}; +generate_exception(5) -> erlang:error(a). + +% В Erlang есть два способа обработки исключений. Первый заключается в +% использовании выражения `try..catch` в функции, в которой возможен выброс +% исключения. +catcher(N) -> + try generate_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% Второй способ заключается в использовании `catch`. Во время поимки исключения +% оно преобразуется в кортеж с информацией об ошибке. +catcher(N) -> catch generate_exception(N). + +``` + +## Ссылки: + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) diff --git a/ru-ru/go-ru.html.markdown b/ru-ru/go-ru.html.markdown new file mode 100644 index 00000000..e06ae9bd --- /dev/null +++ b/ru-ru/go-ru.html.markdown @@ -0,0 +1,336 @@ +--- +language: Go +filename: learngo-ru.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] +translators: + - ["Artem Medeusheyev", "https://github.com/armed"] + - ["Valery Cherepanov", "https://github.com/qumeric"] +lang: ru-ru +--- + +Go - это язык общего назначения, целью которого является удобство, простота, +конкурентность. Это не тренд в компьютерных науках, а новейший и быстрый +способ решать насущные проблемы. + +Концепции Go схожи с другими императивными статически типизированными языками. +Быстро компилируется и быстро исполняется, имеет лёгкие в понимании конструкции +для создания масштабируемых и многопоточных программ. + +Может похвастаться отличной стандартной библиотекой и большим комьюнити, полным +энтузиастов. + +```go +// Однострочный комментарий +/* Многострочный + комментарий */ + +// Ключевое слово package присутствует в начале каждого файла. +// Main это специальное имя, обозначающее исполняемый файл, нежели библиотеку. +package main + +// Import предназначен для указания зависимостей этого файла. +import ( + "fmt" // Пакет в стандартной библиотеке Go + "net/http" // Да, это веб-сервер! + "strconv" // Конвертирование типов в строки и обратно + m "math" // Импортировать math под локальным именем m. +) + +// Объявление функции. Main это специальная функция, служащая точкой входа для +// исполняемой программы. Нравится вам или нет, но Go использует фигурные +// скобки. +func main() { + // Println выводит строку в stdout. + // Данная функция находится в пакете fmt. + fmt.Println("Hello world!") + + // Вызов другой функции из текущего пакета. + beyondHello() +} + +// Функции содержат входные параметры в круглых скобках. +// Пустые скобки все равно обязательны, даже если параметров нет. +func beyondHello() { + var x int // Переменные должны быть объявлены до их использования. + x = 3 // Присвоение значения переменной. + // Краткое определение := позволяет объявить переменную с автоматической + // подстановкой типа из значения. + y := 4 + sum, prod := learnMultiple(x, y) // Функция возвращает два значения. + fmt.Println("sum:", sum, "prod:", prod) // Простой вывод. + learnTypes() // < y minutes, learn more! +} + +// Функция, имеющая входные параметры и возвращающая несколько значений. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Возврат двух значений. +} + +// Некоторые встроенные типы и литералы. +func learnTypes() { + // Краткое определение переменной говорит само за себя. + s := "Learn Go!" // Тип string. + + s2 := `"Чистый" строковой литерал +может содержать переносы строк` // Тоже тип данных string + + // Символ не из ASCII. Исходный код Go в кодировке UTF-8. + g := 'Σ' // тип rune, это алиас для типа int32, содержит символ юникода. + + f := 3.14195 // float64, 64-х битное число с плавающей точкой (IEEE-754). + c := 3 + 4i // complex128, внутри себя содержит два float64. + + // Синтаксис var с инициализациями. + var u uint = 7 // Беззнаковое, но размер зависит от реализации, как и у int. + var pi float32 = 22. / 7 + + // Синтаксис приведения типа с кратким определением + n := byte('\n') // byte – это алиас для uint8. + + // Массивы имеют фиксированный размер на момент компиляции. + var a4 [4]int // массив из 4-х int, инициализирован нулями. + a3 := [...]int{3, 1, 5} // массив из 3-х int, ручная инициализация. + + // Слайсы (slices) имеют динамическую длину. И массивы, и слайсы имеют свои + // преимущества, но слайсы используются гораздо чаще. + s3 := []int{4, 5, 9} // Сравните с a3, тут нет троеточия. + s4 := make([]int, 4) // Выделение памяти для слайса из 4-х int (нули). + var d2 [][]float64 // Только объявление, память не выделяется. + bs := []byte("a slice") // Синтаксис приведения типов. + + p, q := learnMemory() // Объявление p и q как указателей на int. + fmt.Println(*p, *q) // * извлекает указатель. Печатает два int-а. + + // Map, также как и словарь или хеш из некоторых других языков, является + // ассоциативным массивом с динамически изменяемым размером. + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + delete(m, "three") // Встроенная функция, удаляет элемент из map-а. + + // Неиспользуемые переменные в Go являются ошибкой. + // Нижнее подчёркивание позволяет игнорировать такие переменные. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Вывод считается использованием переменной. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // Идем дальше. +} + +// У Go есть полноценный сборщик мусора. В нем есть указатели, но нет арифметики +// указателей. Вы можете допустить ошибку с указателем на nil, но не с +// инкрементацией указателя. +func learnMemory() (p, q *int) { + // Именованные возвращаемые значения p и q являются указателями на int. + p = new(int) // Встроенная функция new выделяет память. + // Выделенный int проинициализирован нулём, p больше не содержит nil. + s := make([]int, 20) // Выделение единого блока памяти под 20 int-ов. + s[3] = 7 // Присвоить значение одному из них. + r := -2 // Определить ещё одну локальную переменную. + return &s[3], &r // Амперсанд(&) обозначает получение адреса переменной. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // If-ы всегда требуют наличие фигурных скобок, но не круглых. + if true { + fmt.Println("told ya") + } + // Форматирование кода стандартизировано утилитой "go fmt". + if false { + // Будущего нет. + } else { + // Жизнь прекрасна. + } + // Используйте switch вместо нескольких if-else. + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Case-ы в Go не "проваливаются" (неявный break). + case 43: + // Не выполнится. + } + // For, как и if не требует круглых скобок + // Переменные, объявленные в for и if являются локальными. + for x := 0; x < 3; x++ { // ++ – это операция. + fmt.Println("итерация", x) + } + // Здесь x == 42. + + // For – это единственный цикл в Go, но у него есть альтернативные формы. + for { // Бесконечный цикл. + break // Не такой уж и бесконечный. + continue // Не выполнится. + } + // Как и в for, := в if-е означает объявление и присвоение значения y, + // проверка y > x происходит после. + if y := expensiveComputation(); y > x { + x = y + } + // Функции являются замыканиями. + xBig := func() bool { + return x > 10000 // Ссылается на x, объявленный выше switch. + } + fmt.Println("xBig:", xBig()) // true (т.к. мы присвоили x = e^10). + x = 1.3e3 // Тут х == 1300 + fmt.Println("xBig:", xBig()) // Теперь false. + + // Метки, куда же без них, их все любят. + goto love +love: + + learnDefer() // Быстрый обзор важного ключевого слова. + learnInterfaces() // О! Интерфейсы, идём далее. +} + +func learnDefer() (ok bool) { + // Отложенные(deferred) выражения выполняются сразу перед тем, как функция + // возвратит значение. + defer fmt.Println("deferred statements execute in reverse (LIFO) order.") + defer fmt.Println("\nThis line is being printed first because") + // defer широко используется для закрытия файлов, чтобы закрывающая файл + // функция находилась близко к открывающей. + return true +} + +// Объявление Stringer как интерфейса с одним методом, String. +type Stringer interface { + String() string +} + +// Объявление pair как структуры с двумя полями x и y типа int. +type pair struct { + x, y int +} + +// Объявление метода для типа pair. Теперь pair реализует интерфейс Stringer. +func (p pair) String() string { // p в данном случае называют receiver-ом. + // Sprintf – ещё одна функция из пакета fmt. + // Обращение к полям p через точку. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Синтаксис с фигурными скобками это "литерал структуры". Он возвращает + // проинициализированную структуру, а оператор := присваивает её p. + p := pair{3, 4} + fmt.Println(p.String()) // Вызов метода String у переменной p типа pair. + var i Stringer // Объявление i как типа с интерфейсом Stringer. + i = p // Валидно, т.к. pair реализует Stringer. + // Вызов метода String у i типа Stringer. Вывод такой же, что и выше. + fmt.Println(i.String()) + + // Функции в пакете fmt сами всегда вызывают метод String у объектов для + // получения строкового представления о них. + fmt.Println(p) // Вывод такой же, что и выше. Println вызывает метод String. + fmt.Println(i) // Вывод такой же, что и выше. + + learnVariadicParams("Учиться", "учиться", "и ещё раз учиться!") +} + +// Функции могут иметь варьируемое количество параметров. +func learnVariadicParams(myStrings ...interface{}) { + // Вывести все параметры с помощью итерации. + for _, param := range myStrings { + fmt.Println("param:", param) + } + + // Передать все варьируемые параметры. + fmt.Println("params:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // Идиома ", ok" служит для обозначения корректного срабатывания чего-либо. + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // ok будет false, потому что 1 нет в map-е. + fmt.Println("тут никого нет") + } else { + fmt.Print(x) // x содержал бы значение, если бы 1 был в map-е. + } + // Идиома ", err" служит для обозначения была ли ошибка или нет. + if _, err := strconv.Atoi("non-int"); err != nil { // _ игнорирует значение + // выведет "strconv.ParseInt: parsing "non-int": invalid syntax" + fmt.Println(err) + } + // Мы ещё обратимся к интерфейсам чуть позже, а пока... + learnConcurrency() +} + +// c – это тип данных channel (канал), объект для конкурентного взаимодействия. +func inc(i int, c chan int) { + c <- i + 1 // когда channel слева, <- являтся оператором "отправки". +} + +// Будем использовать функцию inc для конкурентной инкрементации чисел. +func learnConcurrency() { + // Тот же make, что и в случае со slice. Он предназначен для выделения + // памяти и инициализации типов slice, map и channel. + c := make(chan int) + // Старт трех конкурентных goroutine. Числа будут инкрементированы + // конкурентно и, может быть параллельно, если машина правильно + // сконфигурирована и позволяет это делать. Все они будут отправлены в один + // и тот же канал. + go inc(0, c) // go начинает новую горутину. + go inc(10, c) + go inc(-805, c) + // Считывание всех трех результатов из канала и вывод на экран. + // Нет никакой гарантии в каком порядке они будут выведены. + fmt.Println(<-c, <-c, <-c) // канал справа, <- обозначает "получение". + + cs := make(chan string) // другой канал, содержит строки. + cc := make(chan chan string) // канал каналов со строками. + go func() { c <- 84 }() // пуск новой горутины для отправки значения + go func() { cs <- "wordy" }() // ещё раз, теперь для cs + // Select тоже что и switch, но работает с каналами. Он случайно выбирает + // готовый для взаимодействия канал. + select { + case i := <-c: // полученное значение можно присвоить переменной + fmt.Printf("это %T", i) + case <-cs: // либо значение можно игнорировать + fmt.Println("это строка") + case <-cc: // пустой канал, не готов для коммуникации. + fmt.Println("это не выполнится.") + } + // В этой точке значение будет получено из c или cs. Одна горутина будет + // завершена, другая останется заблокированной. + + learnWebProgramming() // Да, Go это может. +} + +// Всего одна функция из пакета http запускает web-сервер. +func learnWebProgramming() { + // У ListenAndServe первый параметр это TCP адрес, который нужно слушать. + // Второй параметр это интерфейс типа http.Handler. + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // не игнорируйте сообщения об ошибках +} + +// Реализация интерфейса http.Handler для pair, только один метод ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Обработка запроса и отправка данных методом из http.ResponseWriter + w.Write([]byte("You learned Go in Y minutes!")) +} +``` + +## Что дальше + +Основа всех основ в Go это [официальный веб сайт](http://golang.org/). +Там можно пройти туториал, поиграться с интерактивной средой Go и почитать +объёмную документацию. + +Для живого ознакомления рекомендуется почитать исходные коды [стандартной +библиотеки Go](http://golang.org/src/pkg/). Отлично задокументированная, она +является лучшим источником для чтения и понимания Go, его стиля и идиом. Либо +можно, кликнув на имени функции в [документации](http://golang.org/pkg/), +перейти к ее исходным кодам. diff --git a/ru-ru/haskell-ru.html.markdown b/ru-ru/haskell-ru.html.markdown new file mode 100644 index 00000000..e15fe6b7 --- /dev/null +++ b/ru-ru/haskell-ru.html.markdown @@ -0,0 +1,546 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Aleksey Pirogov", "http://astynax.github.io"] +lang: ru-ru +--- + +Haskell разрабатывался, как чистый функциональный язык программирования, применимый на практике. Язык известен благодаря своей системе типов, и "знаменит" благодаря монадам. [Меня][autor] же Haskell заставляет возвращаться к себе снова и снова именно своей элегантностью и [я][autor] получаю истинное удовольствие, программируя на Haskell. + +```haskell +-- Однострочные комментарии начинаются с двух дефисов +{- Многострочный комментарий +заключается в пару фигурных скобок с дефисами с внутренней стороны. +-} + +------------------------------------------------------- +-- 1. Примитивные типы и простейшие операции над ними +------------------------------------------------------- + +-- Числа объявляются просто +3 -- 3 + +-- Арифметика тоже выглядит вполне ожидаемо +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- Операция деления всегда возвращает действительное число +35 / 4 -- 8.75 + +-- Делим нацело так +35 `div` 4 -- 8 + +-- Булевы значения - тоже примитивные значения +True +False + +-- Булева алгебра +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- В примере выше `not`, это функция, принимающая один аргумент. +-- При вызове функции в Haskell список аргументов +-- не нужно заключать в скобки - аргументы просто +-- перечисляются через пробелы сразу после имени функции. +-- Т.о. типичный вызов выглядит так: +-- func arg1 arg2 arg3... +-- Ниже же будет показано, как определять свои функции. + +-- Строки и символы +"Это строка." +'ы' -- а это символ +'Нельзя заключать длинные строки в одинарные кавычки.' -- ошибка! + +-- Строки можно конкатенировать +"Привет" ++ ", Мир!" -- "Привет, Мир!" + +-- При этом строки - это просто списки символов! +"Я - строка!" !! 0 -- 'Я' + + +---------------------------------------------------- +-- Списки и Кортежи +---------------------------------------------------- + +-- Все элементы списка в Haskell +-- должны иметь один и тот же тип. + +-- Эти два списка - эквивалентны: +[1, 2, 3, 4, 5] +[1..5] + +-- Haskell позволяет определять даже бесконечные списки! +[1..] -- список всех натуральных чисел! + +-- Бесконечные списки возможно в Haskell потому, что он "ленив". +-- В Haskell все вычисления производятся тогда и только тогда, +-- когда их результат потребуется. +-- Эта стратегия так и называется - "lazy evaluation". +-- Скажем, если вам нужен тысячный элемент из +-- списка натуральных чисел (бесконечного) и вы напишете так: + +[1..] !! 999 -- 1000 + +-- То Haskell вычислит элементы этого списка от 1 до 1000... +-- ... и остановится, ведь последующие элементы пока не нужны. +-- Это значит, что остальные элементы нашего +-- "бесконечного" списка не будут вычисляться! По крайней мере, +-- пока не понадобятся и они. + +-- Списки можно объединять +[1..5] ++ [6..10] + +-- И добавлять значения в начало +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- А можно обратиться по индексу +[0..] !! 5 -- 5 + +-- Вот ещё несколько функций, часто используемых со списками +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +-- list comprehensions - "формулы" для описания списков +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +-- можно указать условие попадания элементов в список +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Списки могут даже состоять из других списков +[[1,2,3],[4,5,6]] !! 1 !! 2 -- 6 (вторая строка, третий столбец) + +-- Кортежи позволяют своим элементам иметь различные типы, +-- но при этом кортежи имеют фиксированную длину. +-- Кортеж: +("haskell", 1) + +-- Часто кортежи из двух элементов называются "парами". +-- Элементы пары можно получать так: +fst ("haskell", 1) -- "haskell" +snd ("haskell", 1) -- 1 + +---------------------------------------------------- +-- 3. Функции +---------------------------------------------------- +-- Простая функция, принимающая два аргумента +add a b = a + b + +-- Внимание! +-- Если вы используете ghci (интерактивный интерпретатор Haskell), +-- вам нужно использовать ключевое слово `let`, примерно так: +-- let add a b = a + b + +-- Вызовем нашу функцию +add 1 2 -- 3 + +-- Функцию можно поместить между первым и вторым аргументами, +-- если заключить её имя в обратные кавычки +1 `add` 2 -- 3 + +{- Вы можете также определять функции, имя которых +вообще не содержит букв! Таки функции и называются "операторами", +и, да, вы можете определять свои операторы! +Скажем, оператор целочисленного деления можно определить так -} +(//) a b = a `div` b +35 // 4 -- 8 +{- Здесь оператор заключен в скобки - как говорят, +поставлен в префиксную позицию. +В префиксной позиции оператор можно не только определять, +но и вызывать -} +(+) 1 2 -- 3 + +-- Охранные выражения (guards) порой удобны, +-- если наша функция ветвится +fib x + | x < 2 = x + | otherwise = fib (x - 1) + fib (x - 2) + +{- Сопоставление с образцом (pattern matching) +чем-то напоминает охранные выражения. +Здесь мы видим три определения функции fib. +При вызове функции по имени Haskell использует +первое определение, к образцу которого +"подойдет" набор аргументов -} +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Pattern matching для кортежей выглядит так +foo (x, y) = (x + 1, y + 2) + +{- Pattern matching для списков устроен чуть сложнее. +Пусть `x` - первый элемент списка, а `xs` - остальные элементы. +Тогда операции `head` и `tail` могут быть определены так -} +myHead (x:xs) = x +myTail (x:xs) = xs + +-- Функцию отображения мы можем написать так +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- При сопоставлении происходит привязка +-- элементов значения с именами в образце +fstPlusThird (a : _ : b : _) = a + b +fstPlusThird [1,2,3,4,5] -- 4 +-- Значения, для которых вместо имени указано `_`, +-- игнорируются. Это удобно, когда важен сам факт +-- совпадения образца +oneElem [_] = True +oneElem _ = False + +startsWith x (y:_) = x == y +startsWith _ _ = False + +startsWith 'H' "Hello!" -- True +startsWith 'H' "hello!" -- False + +{- Обратите внимание на тот факт, +что первый аргумент нашей функции `myMap` - тоже функция! +Функции, подобно `myMap`, принимающие другие функции +в качестве параметров, или, скажем, возвращающие функции +в качестве результата, называются +Функциями Высших Порядков (ФВП, High Order Functions, HOF) +-} + +-- Вместе с ФВП часто используются анонимные функции +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] +-- Такие функции описываются в виде +-- \arg1 arg1 .. -> expression + +-- Популярные в других языках ФВП присутствуют и в Haskell +map (\x -> x * 10) [1..5] -- [10, 20, 30, 40, 50] +filter (\x -> x > 2) [1..5] -- [3, 4, 5] + +{- Функция свертки +(она же `reduce` или `inject` в других языках) +в Haskell представлены функциями `foldr` и `foldl`. +Суть свертки можно представить так: + +foldl f x0 [x1,x2,x3] -> (f (f (f x0 x1) x2) x3) +foldr f x0 [x1,x2,x3] -> (f x1 (f x2 (f x3 x0))) + +Здесь x0 - начальное значения так называемого "аккумулятора" +-} +-- Эти два вызова дают одинаковый результат +foldr (\x acc -> acc + x) 0 [1..5] -- 15 +foldl (\acc x -> acc + x) 0 [1..5] -- 15 +-- Тут можно даже заменить анонимную функцию на оператор +foldr (+) 0 [1..5] -- 15 +foldl (+) 0 [1..5] -- 15 + +-- Зато здесь разница видна +foldr (\x acc -> (x + 10) : acc) [] [1..3] -- [11, 12, 13] +foldl (\acc x -> (x + 10) : acc) [] [1..3] -- [13, 12, 11] + +{- Часто в качестве начального значения +удобно брать крайнее значение списка (крайнее слева или справа). +Для этого есть пара функций - `foldr1` и `foldl1` -} +foldr1 (+) [1..5] -- 15 +foldl1 (+) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Больше о функциях +---------------------------------------------------- + +{- Каррирование (currying) +Если в Haskell при вызове функции передать не все аргументы, +Функция становится "каррированой" - результатом вызова станет +новая функция, которая при вызове и примет оставшиеся аргументы -} + +add a b = a + b +foo = add 10 -- теперь foo будет принимать число + -- и добавлять к нему 10 +foo 5 -- 15 + +-- Для операторов можно "опустить" любой из двух аргументов +-- Используя этот факт можно определить +-- функцию `foo` из кода выше несколько иначе +foo = (+10) +foo 5 -- 15 + +-- Поупражняемся +map (10-) [1..3] -- [9, 8, 7] +filter (<5) [1..10] -- [1, 2, 3, 4] + +{- Композиция функций +Функция (.) соединяет пару функций в цепочку. +К примеру, можно соединить функцию, добавляющую 10, +с функцией, умножающей на 5 -} +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + +{- Управление приоритетом вычисления +В Haskell есть функция `$`, которая применяет +свой первый аргумент ко второму с наименьшим приоритетом +(обычное применение функций имеет наивысший приоритет) +Эта функция часто позволяет избежать использования +"лишних" скобок -} +head (tail (tail "abcd")) -- 'c' +head $ tail $ tail "abcd" -- 'c' +-- того же эффекта иногда можно достичь использованием композиции +(head . tail . tail) "abcd" -- 'c' +head . tail . tail $ "abcd" -- 'c' +{- Тут стоит сразу запомнить, что композиция функций +возвращает именно новую функцию, как в последнем примере. +Т.е. можно делать так -} +third = head . tail . tail +-- но не так +third = head $ tail $ tail -- (head (tail (tail))) - ошибка! + +---------------------------------------------------- +-- 5. Сигнатуры типов +---------------------------------------------------- + +{- Haskell обладает очень сильной системой типов. +И типизация в Haskell - строгая. Каждое выражение имеет тип, +который может быть описан сигнатурой. +Сигнатура записывается в форме +expression :: type signature +-} + +-- Типы примитивов +5 :: Integer +"hello" :: String +True :: Bool + +{- Функции тоже имеют тип +`not` принимает булево значение и возвращает булев результат +not :: Bool -> Bool + +Вот функция двух аргументов +add :: Integer -> Integer -> Integer + +Тут то мы и видим предпосылки к каррированию: тип +на самом деле выглядит так (скобки просто обычно опускаются) +add :: (Integer -> Integer) -> Integer +т.е. функция принимает аргумент, +и возвращает функцию от второго аргумента! -} + +-- Считается хорошим тоном указывать сигнатуру определений, +-- которые доступны другим разработчикам (публичны). Пример: +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. Управление потоком исполнения +---------------------------------------------------- + +-- Выражение `if` +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- Выражение `if` можно записать и в несколько строк. +-- Соблюдайте отступы! +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- Так как `if` - выражение, ветка `else` обязательна! +-- И более того, результаты выражений в ветках `then` и `else` +-- должны иметь одинаковый тип! + +-- `case`-выражение выглядит так +case args of -- парсим аргументы командной строки + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + +-- При вычислении результата `case`-выражения производится +-- сопоставление с образцом: +fib x = case x of + 1 -> 1 + 2 -> 1 + _ -> fib (x - 1) + fib (x - 2) + +-- В Haskell нет циклов - вместо них используются рекурсия, +-- отображение, фильтрация и свертка (map/filter/fold) +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +for array func = map func array +for [0..3] $ \i -> show i -- ["0", "1", "2", "3"] +for [0..3] show -- ["0", "1", "2", "3"] + +---------------------------------------------------- +-- 7. Пользовательские типы данных +---------------------------------------------------- + +-- Создадим свой Haskell-тип данных + +data Color = Red | Blue | Green + +-- Попробуем использовать + +say :: Color -> String +say Red = "You are Red!" +say Blue = "You are Blue!" +say Green = "You are Green!" + +-- Типы могут иметь параметры (параметры типов) + +data Maybe a = Nothing | Just a + +-- Все эти выражения имеют тип `Maybe` +Just "hello" -- :: `Maybe String` +Just 1 -- :: `Maybe Int` +Nothing -- :: `Maybe a` для любого `a` + +-- Типы могут быть достаточно сложными +data Figure = Rectangle (Int, Int) Int Int + | Square (Int, Int) Int + | Point (Int, Int) + +area :: Figure -> Int +area (Point _) = 0 +area (Square _ s) = s * s +area (Rectangle _ w h) = w * h + +---------------------------------------------------- +-- 8. Ввод-вывод в Haskell +---------------------------------------------------- + +-- Полноценно объяснить тему ввода-вывода невозможно +-- без объяснения монад, но для использования в простых случаях +-- вводного описания будет достаточно. + +-- Когда программа на Haskell выполняется, +-- вызывается функция с именем `main`. +-- Эта функция должна вернуть значение типа `IO ()` +-- Например + +main :: IO () +main = putStrLn $ "Hello, sky! " ++ (say Blue) +-- `putStrLn` имеет тип `String -> IO ()` + +-- Проще всего реализовать программу с вводом-выводом (IO), +-- если вы реализуете функцию с типом `String -> String`. +-- Далее ФВП +-- interact :: (String -> String) -> IO () +-- сделает всё за нас! + +countLines :: String -> String +countLines = show . length . lines +-- здесь `lines` разделяет строку на список строк +-- по символу перевода строки + +main' :: IO () +main' = interact countLines + +{- Вы можете думать о типе `IO ()`, +как о некотором представлении последовательности +действий, которые должен совершить компьютер. +Такое представление напоминает программу +на императивном языке программирования. Для описания +такой последовательности используется `do`-нотация -} + +sayHello :: IO () +sayHello = do + putStrLn "What is your name?" + name <- getLine -- запрашиваем строку и связываем с "name" + putStrLn $ "Hello, " ++ name + +-- Упражнение: +-- напишите свою реализацию функции `interact`, +-- которая запрашивает и обрабатывает только одну строку + +{- Код функции `sayHello` не будет исполняться +при её определении. Единственное место, где IO-действия +могут быть произведены - функция `main`! +Чтобы эта программа выполнила действия в функции `sayHello`, +закомментируйте предыдущее определение функции `main` +и добавьте новое определение: + +main = sayHello -} + +{- Давайте подробнее рассмотрим, как работает функция `getLine` +Её тип: + getLine :: IO String +Вы можете думать, что значение типа `IO a` представляет +собой компьютерную программу, в результате выполнения которой +генерируется значение типа `a`, в дополнение +к остальным эффектам, производимым при выполнении - таким как +печать текста на экран. Это значение типа `a` мы можем +сохранить с помощью оператора `<-`. Мы даже можем реализовать +свое действие, возвращающее значение: -} + +action :: IO String +action = do + putStrLn "This is a line. Duh" + input1 <- getLine + input2 <- getLine + -- Тип блока `do` будет соответствовать типу последнего + -- выполненного в блоке выражения. + -- Заметим, что `return` - не ключевое слово, а функция + -- типа `a -> IO a` + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- Теперь это действие можно использовать вместо `getLine`: + +main'' = do + putStrLn "I will echo two lines!" + result <- action + putStrLn result + putStrLn "This was all, folks!" + +{- Тип `IO` - пример "монады". Языку Haskell нужны монады, +чтобы оставаться преимущественно чистым функциональным языком. +Любые функции, взаимодействующие с внешним миром +(производящие ввод-вывод) имеют `IO` в своих сигнатурах. +Это позволяет судить о функции как о "чистой" - такая не будет +производить ввод-вывод. В ином случая функция - не "чистая". + +Такой подход позволяет очень просто разрабатывать многопоточные +программы - чистые функции, запущенные параллельно +не будут конфликтовать между собой в борьбе за ресурсы. -} + +---------------------------------------------------- +-- 9. Haskell REPL +---------------------------------------------------- + +{- Интерактивная консоль Haskell запускается командой `ghci`. +Теперь можно вводить строки кода на Haskell. +Связывание значений с именами производится +с помощью выражения `let`: -} + +let foo = 5 + +-- Тип значения или выражения можно узнать +-- с помощью команды `:t`: + +>:t foo +foo :: Integer + +-- Также можно выполнять действия с типом `IO ()` + +> sayHello +What is your name? +Friend! +Hello, Friend! + +``` + +Многое о Haskell, например классы типов и монады невозможно уместить в столь короткую статью. Огромное количество очень интересных идей лежит в основе языка, и именно благодаря этому фундаменту на языке так приятно писать код. Позволю себе привести ещё один маленький пример кода на Haskell - реализацию быстрой сортировки: + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Haskell прост в установке, забирайте [здесь](http://www.haskell.org/platform/) и пробуйте! Это же так интересно!. + +Более глубокое погрузиться в язык позволят прекрасные книги +[Learn you a Haskell](http://learnyouahaskell.com/) и +[Real World Haskell](http://book.realworldhaskell.org/). + +[autor]: http://adit.io имеется в виду автор оригинального текста Adit Bhargava *(примечание переводчика)* diff --git a/ru-ru/java-ru.html.markdown b/ru-ru/java-ru.html.markdown new file mode 100644 index 00000000..005495cc --- /dev/null +++ b/ru-ru/java-ru.html.markdown @@ -0,0 +1,506 @@ +--- +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Madison Dickson", "http://github.com/mix3d"] +translators: + - ["Sergey Gaykov", "https://github.com/gaykov"] +filename: LearnJavaRu.java +lang: ru-ru +--- + +Java - это объектно ориентированный язык программирования общего назначения, +основанный на классах и поддерживающий параллельное программирование. +[Подробнее читайте здесь.](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// Однострочные комментарии начинаются с //. +/* +Многострочные комментарии +выглядят так. +*/ +/** +JavaDoc-комментарии выглядят так. Они используются для описания класса +и его членов. +*/ + +// Импорт класса ArrayList из пакета java.util. +import java.util.ArrayList; +// Импорт всех классов из пакета java.security. +import java.security.*; + +// Каждый .java файл содержит один публичный класс, имя которого совпадает с +// именем файла. +public class LearnJavaRu { + + // Программа должна содержать метод main, который является точкой входа. + public static void main (String[] args) { + + // System.out.println используется для печати строк. + System.out.println("Hello World!"); + System.out.println( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Чтобы напечатать что-либо не заканчивая переводом строки + // используется System.out.print. + System.out.print("Hello "); + System.out.print("World"); + + + /////////////////////////////////////// + // Типы и Переменные + /////////////////////////////////////// + + // Переменные объявляются с использованием <тип> <имя> + // Byte - 8-битное целое число. + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - 16-битное целое число. + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - 32-битное целое число. + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - 64-битное целое число. + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L используется для указания на то, что переменная имеет тип long; + // По умолчанию, числа без L являются integer. + + // Замечание: в Java нет беззнаковых типов. + + // Float - 32-битное IEEE 754 число с плавающей запятой с одинарной степенью точности. + float fooFloat = 234.5f; + // f используется для указания на то, что переменная имеет тип float; + // иначе, число являлось бы double. + + // Double - 64-битное IEEE 754 число с плавающей запятой с двойной степенью точности. + double fooDouble = 123.4; + + // Boolean - true или false + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - Простой 16-битный символ Unicode. + char fooChar = 'A'; + + // Переменным final не может быть присвоен другой объект. + final int HOURS_I_WORK_PER_WEEK = 9001; + + // Строки. + String fooString = "My String Is Here!"; + + // \n - это экранированный символ, который означает начало новой строки. + String barString = "Printing on a new line?\nNo Problem!"; + // \t - это экранированный символ, который добавляет символ табуляции. + String bazString = "Do you want to add a tab?\tNo Problem!"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // Массивы + // Размер массива должен быть указан при объявлении. + // Объявлять массив можно в следующих форматах: + //<тип данных> [] <имя> = new <тип данных>[<размер массива>]; + //<тип данных> <имя>[] = new <тип данных>[<размер массива>]; + int [] intArray = new int[10]; + String [] stringArray = new String[1]; + boolean boolArray [] = new boolean[100]; + + // Другой способ объявления и инициализации массива: + int [] y = {9000, 1000, 1337}; + String names [] = {"Bob", "John", "Fred", "Juan Pedro"}; + boolean bools[] = new boolean[] {true, false, false}; + + // Индексация массива - доступ к элементу. + System.out.println("intArray @ 0: " + intArray[0]); + + // Массивы изменяемы и индекс в них начинается с 0. + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // Дополнительно. + // ArrayLists - похож на массив, но предлагает больше возможностей, + // его размер изменяемый. + // LinkedLists - реализация двусвязного списка. Все операции + // выполняются так, как ожидается от двусвязного + // списка. + // Maps - набор объектов, в которых присутствует связь + // ключ-значение. В Map ключ не может дублироваться. + // Каждый ключ связан только с одним значением. + // HashMaps - этот класс использует хэш-таблицу для реализации + // интерфейса Map. Это позволяет сохранить постоянной + // скорость выполнения базовых операций, таких как + // добавление и удаление элементов, вне зависимости + // от размера множества. + + /////////////////////////////////////// + // Операторы + /////////////////////////////////////// + System.out.println("\n->Операторы"); + + int i1 = 1, i2 = 2; // Сокращение для множественного объявления. + + // Арифметика в Java проста. + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 округлено) + + // Остаток от деления + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Операторы сравнения. + System.out.println("3 == 2? " + (3 == 2)); // => false + System.out.println("3 != 2? " + (3 != 2)); // => true + System.out.println("3 > 2? " + (3 > 2)); // => true + System.out.println("3 < 2? " + (3 < 2)); // => false + System.out.println("2 <= 2? " + (2 <= 2)); // => true + System.out.println("2 >= 2? " + (2 >= 2)); // => true + + // Побитовые операторы! + /* + ~ Унарное побитовое дополнение. + << Знаковый сдвиг влево. + >> Знаковый сдвиг вправо. + >>> Беззнаковый сдвиг вправо. + & Побитовое И. + ^ Побитовое исключающее ИЛИ. + | Побитовое ИЛИ. + */ + + // Операторы инкремента. + int i = 0; + System.out.println("\n->Inc/Dec-rementation"); + // Операторы ++ и -- увеличивают и уменьшают значение на 1 соответственно. + // Если они находятся перед переменной, сначала происходит + // увеличение/уменьшение, затем операция, если после, + // то сначала выполняется операция, затем увеличение/уменьшение. + System.out.println(i++); //i = 1, напечатает 0 (пост-инкремент) + System.out.println(++i); //i = 2, напечатает 2 (пре-инкремент) + System.out.println(i--); //i = 1, напечатает 2 (пост-декремент) + System.out.println(--i); //i = 0, напечатает 0 (пре-декремент) + + /////////////////////////////////////// + // Контролирующие операторы. + /////////////////////////////////////// + System.out.println("\n->Контролирующие операторы"); + + // Оператор if такой же, как и в С. + int j = 10; + if (j == 10){ + System.out.println("Я напечатаюсь!"); + } else if (j > 10) { + System.out.println("Я нет."); + } else { + System.out.println("И я тоже нет."); + } + + // Цикл while. + int fooWhile = 0; + while(fooWhile < 100) + { + // System.out.println(fooWhile); + // Увеличить счетчик. + // Будет пройдено 100 итераций, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("Значение fooWhile: " + fooWhile); + + // Цикл Do While. + int fooDoWhile = 0; + do + { + // System.out.println(fooDoWhile); + // Увеличить счетчик. + // Будет пройдено 100 итераций, fooDoWhile 0->99 + fooDoWhile++; + } while(fooDoWhile < 100); + System.out.println("Значение fooDoWhile: " + fooDoWhile); + + // Цикл for. + int fooFor; + // Структура цикла for => for(<начальное_состояние>; <условие>; <шаг>) + for(fooFor=0; fooFor<10; fooFor++){ + // System.out.println(fooFor); + // Пройдет 10 итераций., fooFor 0->9 + } + System.out.println("Значение fooFor: " + fooFor); + + // Цикл For Each + // Автоматический проход через массив или список объектов. + int[] fooList = {1,2,3,4,5,6,7,8,9}; + // Структура цикла for each => for(<объект> : <объект_массив>) + // читается как: для каждого объекта в массиве + // заметка: тип объекта должен совпадать с типом массива. + + for( int bar : fooList ){ + System.out.println(bar); + //Пройдет 9 итераций и напечатает 1-9 на новых строках. + } + + // Switch Case + // switch работает с типами byte, short, char и int. + // Также он работает с перечислениями, + // классом String и с некоторыми классами-обертками над + // примитивными типами: Character, Byte, Short и Integer. + int month = 3; + String monthString; + switch (month){ + case 1: + monthString = "Январь"; + break; + case 2: + monthString = "Февраль"; + break; + case 3: + monthString = "Март"; + break; + default: + monthString = "Другой месяц"; + break; + } + System.out.println("Результат Switch Case: " + monthString); + + // Сокращенный синтаксис условного оператора. + // Вы можете использовать этот синтаксис для быстрого присвоения + // или логических переходов. + // Читается так: "Если (условие) истинно, использовать <значение 1>, + // в ином случае, использовать <значение 2>" + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Напечатает А, потому что условие истинно + + + /////////////////////////////////////// + // Преобразование и приведение типов данных. + /////////////////////////////////////// + + // Преобразование данных. + + // Преобразование строки в число. + Integer.parseInt("123"); // Вернет числовое представление "123". + + // Преобразование числа в строку + Integer.toString(123); // Вернет строковое представление 123. + + // Для других преобразований смотрите следующие классы: + // Double + // Long + // String + + // Приведение типов + // Вы так же можете приводить типы в Java. + // Подробнее об этом можно узнать по ссылке: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Классы и Функции + /////////////////////////////////////// + + System.out.println("\n->Классы и Функции"); + + // (Класс Bicycle определен ниже) + + // Для создания экземпляра класса используется new. + Bicycle trek = new Bicycle(); + + // Вызов методов объекта. + trek.speedUp(3); // Вы должны всегда использовать сеттеры и геттеры. + trek.setCadence(100); + + // toString возвращает строковое представление объекта. + System.out.println("trek info: " + trek.toString()); + + } // Конец метода main. +} // Конец класса LearnJava. + + +// Вы можете включать другие, не публичные классы в .java файл. + + +// Синтаксис объявления класса: +// <public/private/protected> class <имя класса>{ +// // Поля с данными, конструкторы, функции, все внутри. +// // Функции называют методами в Java. +// } + +class Bicycle { + + // Поля/Переменные класса Bicycle. + public int cadence;// Публичные(public): Доступны из любого места. + private int speed; // Приватные(private): Доступны только внутри класса. + protected int gear;// Защищенные(protected): Доступ из класса и наследников. + String name; // по умолчанию: Доступны только внутри пакета. + + // Конструкторы - способ создания класса. + // Это конструктор: + public Bicycle() { + gear = 1; + cadence = 50; + speed = 5; + name = "Bontrager"; + } + + // Это конструктор, который принимает аргументы: + public Bicycle(int startCadence, int startSpeed, int startGear, String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // Синтаксис функций: + // <public/private/protected> <тип возвращаемого значения> <имя>(<аргументы>) + + // Классы в Java часто реализуют сеттеры и геттеры для своих полей. + + // Синтаксис определения метода: + // <модификатор> <тип возвращаемого значения> <имя>(<аргументы>) + public int getCadence() { + return cadence; + } + + // void-методы не возвращают значений. + public void setCadence(int newValue) { + cadence = newValue; + } + + public void setGear(int newValue) { + gear = newValue; + } + + public void speedUp(int increment) { + speed += increment; + } + + public void slowDown(int decrement) { + speed -= decrement; + } + + public void setName(String newName) { + name = newName; + } + + public String getName() { + return name; + } + + //Метод для отображения значений атрибутов объекта. + @Override + public String toString() { + return "gear: " + gear + + " cadence: " + cadence + + " speed: " + speed + + " name: " + name; + } +} // конец класса Bicycle. + +// PennyFarthing - это класс, наследованный от Bicycle +class PennyFarthing extends Bicycle { + // (Penny Farthings - это такие велосипеды с большим передним колесом, + // у них нет передач.) + + public PennyFarthing(int startCadence, int startSpeed){ + // Вызов конструктора родительского класса. + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // Вы должны пометить метод, который переопределяете, при помощи @аннотации + // Чтобы узнать о том, что такое аннотации и зачем они нужны, почитайте: + // http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } + +} + +// Интерфейсы +// Синтаксис определения интерфейса: +// <модификатор доступа> interface <имя> extends <базовый интерфейс> { +// // Константы +// // Определение методов. +//} + +// Пример - Еда: +public interface Edible { + // Любой класс, реализующий этот интерфейс, должен реализовать этот метод. + public void eat(); +} + +public interface Digestible { + public void digest(); +} + + +// Сейчас мы можем создать класс, реализующий оба эти интерфейса. +public class Fruit implements Edible, Digestible { + public void eat() { + //... + } + + public void digest() { + //... + } +} + +// В Java Вы можете наследоватьтолько один класс, однако можете реализовывать +// несколько интерфейсов. Например: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { + public void InterfaceOneMethod() { + + } + + public void InterfaceTwoMethod() { + + } +} + +``` + +## Почитать еще + +Здесь приведены ссылки только для того, чтобы получить общее представление о Java. Гуглите, чтобы найти какие-либо конкретные примеры. + +**Официальные руководства Oracle**: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Модификаторы доступа в Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Концепции объектно-ориентированного программирования](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Наследование](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Полиморфизм](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Абстракция](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Исключения](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Интерфейсы](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) + +**Уроки онлайн** + +* [Learneroo.com - Изучение Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Книги**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) + +* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300) + + diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown new file mode 100644 index 00000000..8655ae4a --- /dev/null +++ b/ru-ru/javascript-ru.html.markdown @@ -0,0 +1,513 @@ +--- +language: javascript +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +filename: javascript-ru.js +translators: + - ["Alexey Gonchar", "http://github.com/finico"] + - ["Andre Polykanine", "https://github.com/Oire"] +lang: ru-ru +--- + +JavaScript был создан в 1995 году Бренданом Айком, работавшим в компании Netscape. +Изначально он был задуман как простой язык сценариев для веб-сайтов, дополняющий +Java для более сложных веб-приложений, но его тесная интеграция с веб-страницами +и встроенная поддержка браузерами привели к тому, что он стал более распространённым, +чем Java в веб-интерфейсах. + +JavaScript не ограничивается только веб-браузером: например, Node.js, программная +платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера +Google Chrome, становится все более популярной. + +```js +// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш, +/* а многострочные комментарии начинаются с последовательности слэш-звёздочка + и заканчиваются символами звёздочка-слэш */ + +// Инструкции могут заканчиваться точкой с запятой ; +doStuff(); + +// ... но она необязательна, так как точки с запятой автоматически вставляются +// везде, где есть символ новой строки, за некоторыми исключениями. +doStuff() + +// Так как эти исключения могут привести к неожиданным результатам, мы будем всегда +// использовать точку с запятой в этом руководстве. + +/////////////////////////////////// +// 1. Числа, Строки и Операторы + +// В JavaScript только один тип числа (64-bit IEEE 754 double). +// Он имеет 52-битную мантиссу, которой достаточно для хранения целых чисел +// с точностью вплоть до 9✕10¹⁵. +3; // = 3 +1.5; // = 1.5 + +// Некоторые простые арифметические операции работают так, как вы ожидаете. +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 (а некоторые - нет) +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Включая деление с остатком. +5 / 2; // = 2.5 + +// Побитовые операции также имеются; когда вы проводите такую операцию, +// ваше число с плавающей запятой переводится в целое со знаком +// длиной *до* 32 разрядов. +1 << 2; // = 4 + +// Приоритет в выражениях можно явно задать скобками. +(1 + 3) * 2; // = 8 + +// Есть три специальных значения, которые не являются реальными числами: +Infinity; // "бесконечность", например, результат деления на 0 +-Infinity; // "минус бесконечность", результат деления отрицательного числа на 0 +NaN; // "не число", например, результат деления 0/0 + +// Существует также логический тип. +true; +false; + +// Строки создаются при помощи двойных или одинарных кавычек. +'абв'; +"Привет, мир!"; + +// Для логического отрицания используется восклицательный знак. +!true; // = false +!false; // = true + +// Строгое равенство === +1 === 1; // = true +2 === 1; // = false + +// Строгое неравенство !== +1 !== 1; // = false +2 !== 1; // = true + +// Другие операторы сравнения +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Строки объединяются при помощи оператора + +"привет, " + "мир!"; // = "Привет, мир!" + +// и сравниваются при помощи < и > +"a" < "b"; // = true + +// Проверка равенства с приведением типов осуществляется двойным символом равно +"5" == 5; // = true +null == undefined; // = true + +// ...если только не использовать === +"5" === 5; // = false +null === undefined; // = false + +// ...приведение типов может привести к странному поведению... +13 + !0; // 14 +"13" + !0; // '13true' + +// Вы можете получить доступ к любому символу строки, используя метод charAt +"Это строка".charAt(0); // = 'Э' + +// ...или используйте метод substring, чтобы получить более крупные части +"Привет, мир".substring(0, 6); // = "Привет" + +// length - это свойство, для его получения не нужно использовать () +"Привет".length; // = 6 + +// Также есть null и undefined +null; // Намеренное отсутствие значения +undefined; // используется для обозначения переменных, не имеющих + // присвоенного значения (хотя непосредственно undefined + // является значением) + +// false, null, undefined, NaN, 0 и "" — это ложь; всё остальное - истина. +// Следует отметить, что 0 — это ложь, а "0" — истина, несмотря на то, что +// 0 == "0". + +/////////////////////////////////// +// 2. Переменные, Массивы и Объекты + +// Переменные объявляются при помощи ключевого слова var. JavaScript — язык с +// динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания +// значения переменной используется символ = +var someVar = 5; + +// если вы пропустите слово var, вы не получите сообщение об ошибке, ... +someOtherVar = 10; + +// ...но ваша переменная будет создана в глобальном контексте, а не в текущем, +// где вы ее объявили. + +// Переменным, объявленным без присвоения, устанавливается значение undefined. +var someThirdVar; // = undefined + +// У математических операций есть сокращённые формы: +someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10 +someVar *= 10; // теперь someVar имеет значение 100 + +// Ещё более краткая запись увеличения и уменьшения на единицу: +someVar++; // теперь someVar имеет значение 101 +someVar--; // вернулись к 100 + +// Массивы — это нумерованные списки, содержащие значения любого типа. +var myArray = ["Привет", 45, true]; + +// Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками. +// Индексы массивов начинаются с нуля. +myArray[1]; // = 45 + +// Массивы можно изменять, как и их длину, +myArray.push("Мир"); +myArray.length; // = 4 + +// добавлять и редактировать определённый элемент +myArray[3] = "Привет"; + +// Объекты в JavaScript похожи на словари или ассоциативные массивы в других +// языках: неупорядоченный набор пар ключ-значение. +var myObj = {key1: "Привет", key2: "Мир"}; + +// Ключи — это строки, но кавычки необязательны, если строка удовлетворяет +// ограничениям для имён переменных. Значения могут быть любых типов. +var myObj = {myKey: "myValue", "my other key": 4}; + +// Атрибуты объектов можно также получить, используя квадратные скобки +myObj["my other key"]; // = 4 + +// или через точку, при условии, что ключ является допустимым идентификатором. +myObj.myKey; // = "myValue" + +// Объекты изменяемы; можно изменять значения и добавлять новые ключи. +myObj.myThirdKey = true; + +// Если вы попытаетесь получить доступ к несуществующему значению, +// вы получите undefined. +myObj.myFourthKey; // = undefined + +/////////////////////////////////// +// 3. Логика и управляющие конструкции. + +// Синтаксис для этого раздела почти такой же, как в Java. + +// Условная конструкция работает, как и следовало ожидать, +var count = 1; +if (count == 3) { + // выполняется, если count равен 3 +} else if (count == 4) { + // выполняется, если count равен 4 +} else { + // выполняется, если не 3 и не 4 +} + +// ...как и цикл while. +while (true){ + // Бесконечный цикл! +} + +// Цикл do-while такой же, как while, но он всегда выполняется хотя бы раз. +var input +do { + input = getInput(); +} while (!isValid(input)) + +// цикл for такой же, как в C и Java: +// инициализация; условие; шаг. +for (var i = 0; i < 5; i++) { + // выполнится 5 раз +} + +// && — это логическое И, || — это логическое ИЛИ +if (house.size == "big" && house.color == "blue") { + house.contains = "bear"; +} +if (color == "red" || color == "blue") { + // цвет красный или синий +} + +// && и || используют сокращённое вычисление, что полезно +// для задания значений по умолчанию. +var name = otherName || "default"; + +// Оператор switch выполняет проверку на равенство при помощи === +// используйте break, чтобы прервать выполнение после каждого case, +// или выполнение пойдёт далее даже после правильного варианта. +grade = 4; +switch (grade) { + case 5: + console.log("Отлично"); + break; + case 4: + console.log("Хорошо"); + break; + case 3: + console.log("Можете и лучше"); + break; + default: + console.log("Ой-вей!"); + break; +} + + +/////////////////////////////////// +// 4. Функции, Область видимости и Замыкания + +// Функции в JavaScript объявляются при помощи ключевого слова function. +function myFunction(thing) { + return thing.toUpperCase(); +} +myFunction("foo"); // = "FOO" + +// Обратите внимание, что значение, которое будет возвращено, должно начинаться +// на той же строке, что и ключевое слово return, в противном случае вы будете +// всегда возвращать undefined по причине автоматической вставки точки с запятой. +// Следите за этим при использовании стиля форматирования Allman. +function myFunction() +{ + return // <- здесь точка с запятой вставится автоматически + { + thisIsAn: 'object literal' + } +} +myFunction(); // = undefined + +// В JavaScript функции — это объекты первого класса, поэтому они могут быть +// присвоены различным именам переменных и передаваться другим функциям +// в качестве аргументов, например, когда назначается обработчик события: +function myFunction() { + // этот код будет вызван через 5 секунд +} +setTimeout(myFunction, 5000); +// Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js + +// Функции не обязательно должны иметь имя при объявлении — вы можете написать +// анонимное определение функции непосредственно в аргументе другой функции. +setTimeout(function() { + // этот код будет вызван через 5 секунд +}, 5000); + +// В JavaScript есть область видимости; функции имеют свою область +// видимости, а другие блоки — нет. +if (true) { + var i = 5; +} +i; // = 5, а не undefined, как ожидалось бы в языках с блочной областью видимости + +// Это привело к общепринятому шаблону "самозапускающихся анонимных функций", +// которые препятствуют проникновению переменных в глобальную область видимости +(function() { + var temporary = 5; + // Мы можем получить доступ к глобальной области для записи в «глобальный объект», + // который в веб-браузере всегда window. Глобальный объект может иметь другое + // имя в таких платформах, как Node.js + window.permanent = 10; +})(); +temporary; // вызовет сообщение об ошибке с типом ReferenceError +permanent; // = 10 + +// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция +// определена внутри другой функции, то внутренняя функция имеет доступ к +// переменным внешней функции даже после того, как контекст выполнения выйдет из +// внешней функции. +function sayHelloInFiveSeconds(name) { + var prompt = "Привет, " + name + "!"; + // Внутренние функции по умолчанию помещаются в локальную область видимости, + // как если бы они были объявлены с помощью var. + function inner() { + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет, + // после чего setTimeout вызовет функцию inner. Однако поскольку функция inner + // «замкнута» вокруг sayHelloInFiveSeconds, она по-прежнему имеет доступ к переменной prompt + // на то время, когда она наконец будет вызвана. +} +sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!» + +/////////////////////////////////// +// 5. Подробнее об объектах; конструкторы и прототипы + +// Объекты могут содержать в себе функции. +var myObj = { + myFunc: function() { + return "Привет, мир!"; + } +}; +myObj.myFunc(); // = "Привет, мир!" + +// Когда вызываются функции, прикреплённые к объекту, они могут получить доступ +// к этому объекту с помощью ключевого слова this. +myObj = { + myString: "Привет, мир!", + myFunc: function() { + return this.myString; + } +}; +myObj.myFunc(); // = "Привет, мир!" + +// Значение this зависит от того, как функция вызывается, +// а не от того, где она определена. Таким образом, наша функция не работает, +// если она вызывается не в контексте объекта. +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// И наоборот, функция может быть присвоена объекту и получать доступ к нему +// через this, даже если она не была прикреплена к нему при объявлении. +var myOtherFunc = function() { +} +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!" + +// Мы можем также указать контекст для выполнения функции при её вызове, +// используя call или apply. +var anotherFunc = function(s) { + return this.myString + s; +} +anotherFunc.call(myObj, " И привет, Луна!"); // = "Привет, мир! И привет, Луна!" + +// Функция apply почти такая же, но принимает в качестве списка аргументов массив. +anotherFunc.apply(myObj, [" И привет, Солнце!"]); // = "Привет, мир! И привет, Солнце!" + +// Это полезно при работе с функцией, которая принимает последовательность +// аргументов, а вы хотите передать массив. +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (Ой-ой!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Но call и apply — только временные. Когда мы хотим связать функцию с объектом, +// мы можем использовать bind. +var boundFunc = anotherFunc.bind(myObj); +boundFunc(" И привет, Сатурн!"); // = "Привет, мир! И привет, Сатурн!" + +// Bind также может использоваться для частичного применения (каррирования) функции +var product = function(a, b) { return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// Когда вы вызываете функцию с помощью ключевого слова new, создается новый объект, +// доступный функции при помощи this. Такие функции называют конструкторами. +var MyConstructor = function() { + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// У каждого объекта в JavaScript есть прототип. Когда вы хотите получить +// доступ к свойству объекта, которое не существует в этом объекте, интерпретатор +// будет искать это свойство в прототипе. + +// Некоторые реализации языка позволяют получить доступ к прототипу объекта +// через «магическое» свойство __proto__. Несмотря на то, что это может быть полезно +// для понимания прототипов, это не часть стандарта; мы увидим стандартные способы +// использования прототипов позже. +var myObj = { + myString: "Привет, мир!" +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function() { + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 + +// Для функций это тоже работает. +myObj.myFunc(); // = "Привет, мир!" + +// Если интерпретатор не найдёт свойство в прототипе, то продожит поиск +// в прототипе прототипа и так далее. +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + +// Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип. +// Это означает, что мы можем изменить прототип, и наши изменения будут отражены везде. +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + +// Мы упомянули, что свойство __proto__ нестандартно, и нет никакого стандартного +// способа, чтобы изменить прототип существующего объекта. Однако есть два +// способа создать новый объект с заданным прототипом. + +// Первый способ — это Object.create, который появился в JavaScript недавно, +// а потому доступен ещё не во всех реализациях языка. +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// Второй способ, который работает везде, имеет дело с конструкторами. +// У конструкторов есть свойство с именем prototype. Это *не* прототип +// функции-конструктора; напротив, это прототип для новых объектов, которые +// будут созданы с помощью этого конструктора и ключевого слова new. +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function() { + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// У встроенных типов, таких, как строки и числа, также есть конструкторы, которые +// создают эквивалентные объекты-обёртки. +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// За исключением того, что они не в точности равны. +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0) { + // Этот код не выполнится, потому что 0 - это ложь. +} + +// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы, +// поэтому вы можете расширить функционал строк, например: +String.prototype.firstCharacter = function() { + return this.charAt(0); +} +"abc".firstCharacter(); // = "a" + +// Это часто используется в т.н. полифилах, которые реализуют новые возможности +// JavaScript в старой реализации языка, так что они могут быть использованы в +// старых средах, таких, как устаревшие браузеры. + +// Например, мы упомянули, что Object.create доступен не во всех реализациях, но +// мы сможем использовать его с помощью такого полифила: +if (Object.create === undefined) { // не перезаписываем метод, если он существует + Object.create = function(proto) { + // создаём временный конструктор с правильным прототипом + var Constructor = function(){}; + Constructor.prototype = proto; + // затем используем его для создания нового, + // правильно прототипированного объекта + return new Constructor(); + } +} +``` + +## Что ещё почитать + +[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) — +качественный учебник по JavaScript на русском языке. + +[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) — +предоставляет отличную документацию для JavaScript, как он используется в браузерах. +Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим, +делясь своими знаниями. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — это +подробное руководство по всем неинтуитивным особенностей языка. + +[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) — можно +найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому. diff --git a/ru-ru/json-ru.html.markdown b/ru-ru/json-ru.html.markdown new file mode 100644 index 00000000..52af3696 --- /dev/null +++ b/ru-ru/json-ru.html.markdown @@ -0,0 +1,61 @@ +--- +language: json +filename: learnjson-ru.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +JSON - это очень простой формат обмена данными, и это будет самый легкий +курс из когда-либо представленных "Learn X in Y Minutes". + +В чистом виде у JSON нет фактических комментариев, но большинство парсеров примут +комментарии в Си-стиле (//, /\* \*/). Для таких целей, конечно, все правильно +будет на 100% с точки зрения JSON. К счастью, в нашем случае данные скажут сами за себя. + +```json +{ + "ключ": "значение", + + "ключи": "должны всегда заключаться в двойные кавычки", + "числа": 0, + "строки": "Пρивет, миρ. Допускаются все unicode-символы вместе с \"экранированием\".", + "содержит логический тип?": true, + "ничего": null, + + "большое число": 1.2e+100, + + "объекты": { + "комментарий": "Большинство ваших структур будут представлять из себя объекты.", + + "массив": [0, 1, 2, 3, "Массивы могут содержать в себе любой тип.", 5], + + "другой объект": { + "комментарий": "Они могут быть вложенными, и это очень полезно." + } + }, + + "бессмыслие": [ + { + "источники калия": ["бананы"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "нео"], + [0, 0, 0, 1] + ] + ], + + "альтернативный стиль": { + "комментарий": "проверьте это!" + , "позиция запятой": "неважна, хоть и перед значением, все равно правильно" + , "еще один комментарий": "как хорошо" + }, + + "это было недолго": "И вы справились. Теперь вы знаете все о JSON." +} +``` diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown new file mode 100644 index 00000000..29392604 --- /dev/null +++ b/ru-ru/julia-ru.html.markdown @@ -0,0 +1,750 @@ +--- +language: Julia +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Sergey Skovorodkin", "https://github.com/skovorodkin"] +filename: learnjulia-ru.jl +lang: ru-ru +--- + +Julia — гомоиконный функциональный язык программирования для технических расчётов. +Несмотря на полную поддержку гомоиконных макросов, функций первого класса и конструкций управления низкого уровня, этот язык так же прост в изучении и применении, как и Python. + +Документ описывает текущую dev-версию Julia от 18-о октября 2013 года. + +```ruby + +# Однострочные комментарии начинаются со знака решётки. + +#################################################### +## 1. Примитивные типы данных и операторы +#################################################### + +# Всё в Julia — выражение. + +# Простые численные типы +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# Доступны все привычные инфиксные операторы +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # деление Int на Int всегда возвращает Float +div(5, 2) # => 2 # для округления к нулю используется div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # возведение в степень +12 % 10 # => 2 + +# С помощью скобок можно изменить приоритет операций +(1 + 3) * 2 # => 8 + +# Побитовые операторы +~2 # => -3 # НЕ (NOT) +3 & 5 # => 1 # И (AND) +2 | 4 # => 6 # ИЛИ (OR) +2 $ 4 # => 6 # сложение по модулю 2 (XOR) +2 >>> 1 # => 1 # логический сдвиг вправо +2 >> 1 # => 1 # арифметический сдвиг вправо +2 << 1 # => 4 # логический/арифметический сдвиг влево + +# Функция bits возвращает бинарное представление числа +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# Логические значения являются примитивами +true +false + +# Булевы операторы +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# Сравнения можно объединять цепочкой +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# Строки объявляются с помощью двойных кавычек — " +"This is a string." + +# Символьные литералы создаются с помощью одинарных кавычек — ' +'a' + +# Строки индексируются как массивы символов +"This is a string"[1] # => 'T' # Индексы начинаются с единицы +# Индексирование не всегда правильно работает для UTF8-строк, +# поэтому рекомендуется использовать итерирование (map, for-циклы и т.п.). + +# Для строковой интерполяции используется знак доллара ($): +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# В скобках можно использовать любое выражение языка. + +# Другой способ форматирования строк — макрос printf +@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 + +#################################################### +## 2. Переменные и коллекции +#################################################### + +# Вывод +println("I'm Julia. Nice to meet you!") + +# Переменные инициализируются без предварительного объявления +some_var = 5 # => 5 +some_var # => 5 + +# Попытка доступа к переменной до инициализации вызывает ошибку +try + some_other_var # => ERROR: some_other_var not defined +catch e + println(e) +end + +# Имена переменных начинаются с букв. +# После первого символа можно использовать буквы, цифры, +# символы подчёркивания и восклицательные знаки. +SomeOtherVar123! = 6 # => 6 + +# Допустимо использование unicode-символов +☃ = 8 # => 8 +# Это особенно удобно для математических обозначений +2 * π # => 6.283185307179586 + +# Рекомендации по именованию: +# * имена переменных в нижнем регистре, слова разделяются символом +# подчёркивания ('\_'); +# +# * для имён типов используется CamelCase; +# +# * имена функций и макросов в нижнем регистре +# без разделения слов символом подчёркивания; +# +# * имя функции, изменяющей переданные ей аргументы (in-place function), +# оканчивается восклицательным знаком. + +# Массив хранит последовательность значений, индексируемых с единицы до n: +a = Int64[] # => пустой массив Int64-элементов + +# Одномерный массив объявляется разделёнными запятой значениями. +b = [4, 5, 6] # => массив из трёх Int64-элементов: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# Строки двумерного массива разделяются точкой с запятой. +# Элементы строк разделяются пробелами. +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] + +# push! и append! добавляют в список новые элементы +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# pop! удаляет из списка последний элемент +pop!(b) # => возвращает 6; массив b снова равен [4,5] + +# Вернём 6 обратно +push!(b,6) # b снова [4,5,6]. + +a[1] # => 1 # индексы начинаются с единицы! + +# Последний элемент можно получить с помощью end +a[end] # => 6 + +# Операции сдвига +shift!(a) # => 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# Восклицательный знак на конце названия функции означает, +# что функция изменяет переданные ей аргументы. +arr = [5,4,6] # => массив из 3 Int64-элементов: [5,4,6] +sort(arr) # => [4,5,6]; но arr равен [5,4,6] +sort!(arr) # => [4,5,6]; а теперь arr — [4,5,6] + +# Попытка доступа за пределами массива выбрасывает BoundsError +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# Вывод ошибок содержит строку и файл, где произошла ошибка, +# даже если это случилось в стандартной библиотеке. +# Если вы собрали Julia из исходных кодов, +# то найти эти файлы можно в директории base. + +# Создавать массивы можно из последовательности +a = [1:5] # => массив из 5 Int64-элементов: [1,2,3,4,5] + +# Срезы +a[1:3] # => [1, 2, 3] +a[2:] # => [2, 3, 4, 5] +a[2:end] # => [2, 3, 4, 5] + +# splice! удаляет элемент из массива +# Remove elements from an array by index with splice! +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr теперь равен [3,5] + +# append! объединяет списки +b = [1,2,3] +append!(a,b) # теперь a равен [1, 2, 3, 4, 5, 1, 2, 3] + +# Проверка на вхождение +in(1, a) # => true + +# Длина списка +length(a) # => 8 + +# Кортеж — неизменяемая структура. +tup = (1, 2, 3) # => (1,2,3) # кортеж (Int64,Int64,Int64). +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# Многие функции над списками работают и для кортежей +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +# Кортежи можно распаковывать в переменные +a, b, c = (1, 2, 3) # => (1,2,3) # a = 1, b = 2 и c = 3 + +# Скобки из предыдущего примера можно опустить +d, e, f = 4, 5, 6 # => (4,5,6) + +# Кортеж из одного элемента не равен значению этого элемента +(1,) == 1 # => false +(1) == 1 # => true + +# Обмен значений +e, d = d, e # => (5,4) # d = 5, e = 4 + + +# Словари содержат ассоциативные массивы +empty_dict = Dict() # => Dict{Any,Any}() + +# Для создания словаря можно использовать литерал +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# Значения ищутся по ключу с помощью оператора [] +filled_dict["one"] # => 1 + +# Получить все ключи +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Заметьте, словарь не запоминает порядок, в котором добавляются ключи. + +# Получить все значения. +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# То же касается и порядка значений. + +# Проверка вхождения ключа в словарь +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# Попытка обратиться к несуществующему ключу выбросит ошибку +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# Используйте метод get со значением по умолчанию, чтобы избежать этой ошибки +# get(dictionary,key,default_value) +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# Для коллекций неотсортированных уникальных элементов используйте Set +empty_set = Set() # => Set{Any}() +# Инициализация множества +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# Добавление элементов +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# Проверка вхождения элементов во множество +in(2, filled_set) # => true +in(10, filled_set) # => false + +# Функции для получения пересечения, объединения и разницы. +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + + +#################################################### +## 3. Поток управления +#################################################### + +# Создадим переменную +some_var = 5 + +# Выражение if. Отступы не имеют значения. +if some_var > 10 + println("some_var is totally bigger than 10.") +elseif some_var < 10 # Необязательная ветка elseif. + println("some_var is smaller than 10.") +else # else-ветка также опциональна. + println("some_var is indeed 10.") +end +# => prints "some var is smaller than 10" + + +# Цикл for проходит по итерируемым объектам +# Примеры итерируемых типов: Range, Array, Set, Dict и String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # Для вставки значения переменной или выражения в строку используется $ +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Другой вариант записи. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Цикл while выполняется до тех пор, пока верно условие +x = 0 +while x < 4 + println(x) + x += 1 # Короткая запись x = x + 1 +end +# Выведет: +# 0 +# 1 +# 2 +# 3 + +# Обработка исключений +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. Функции +#################################################### + +# Для определения новой функции используется ключевое слово 'function' +#function имя(аргументы) +# тело... +#end +function add(x, y) + println("x is $x and y is $y") + + # Функция возвращает значение последнего выражения + x + y +end + +add(5, 6) # => Вернёт 11, напечатав "x is 5 and y is 6" + +# Функция может принимать переменное количество позиционных аргументов. +function varargs(args...) + return args + # для возвращения из функции в любом месте используется 'return' +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# Многоточие (...) — это splat. +# Мы только что воспользовались им в определении функции. +# Также его можно использовать при вызове функции, +# где он преобразует содержимое массива или кортежа в список аргументов. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # формирует множество массивов +Set([1,2,3]...) # => Set{Int64}(1,2,3) # эквивалентно Set(1,2,3) + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # множество кортежей +Set(x...) # => Set{Int64}(2,3,1) + + +# Опциональные позиционные аргументы +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# Именованные аргументы +function keyword_args(;k1=4,name2="hello") # обратите внимание на ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k2"=>4] + +# В одной функции можно совмещать все виды аргументов +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# Выведет: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Функции в Julia первого класса +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# Анонимная функция +(x -> x > 2)(3) # => true + +# Эта функция идентичная предыдущей версии create_adder +function create_adder(x) + y -> x + y +end + +# Если есть желание, можно воспользоваться полным вариантом +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# Встроенные функции высшего порядка +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Списковые сборки +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. Типы +#################################################### + +# Julia has a type system. +# Каждое значение имеет тип, но переменные не определяют тип значения. +# Функция `typeof` возвращает тип значения. +typeof(5) # => Int64 + +# Types are first-class values +# Типы являются значениями первого класса +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# Тип DataType представляет типы, включая себя самого. + +# Типы используются в качестве документации, для оптимизации и организации. +# Статически типы не проверяются. + +# Пользователь может определять свои типы +# Типы похожи на структуры в других языках +# Новые типы определяются с помощью ключевого слова `type` + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # отсутствие типа равносильно `::Any` +end + +# Аргументы конструктора по умолчанию — свойства типа +# в порядке их определения. +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# Тип объекта по сути является конструктором значений такого типа +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# Эти типы, похожие на структуры, называются конкретными. +# Можно создавать объекты таких типов, но не их подтипы. +# Другой вид типов — абстрактные типы. + +# abstract Name +abstract Cat # просто имя и точка в иерархии типов + +# Объекты абстрактных типов создавать нельзя, +# но зато от них можно наследовать подтипы. +# Например, Number — это абстрактный тип. +subtypes(Number) # => 6 элементов в массиве Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => пустой массив Array{Any,1} + +# У всех типов есть супертип. Для его определения есть функция `super`. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# Все эти типы, за исключением Int64, абстрактные. + +# Для создания подтипа используется оператор <: +type Lion <: Cat # Lion — это подтип Cat + mane_color + roar::String +end + +# У типа может быть несколько конструкторов. +# Для создания нового определите функцию с именем, как у типа, +# и вызовите имеющийся конструктор. +Lion(roar::String) = Lion("green",roar) +# Мы создали внешний (т.к. он находится вне определения типа) конструктор. + +type Panther <: Cat # Panther — это тоже подтип Cat + eye_color + + # Определим свой конструктор вместо конструктора по умолчанию + Panther() = new("green") +end +# Использование внутренних конструкторов позволяет +# определять, как будут создаваться объекты типов. +# Но по возможности стоит пользоваться внешними конструкторами. + +#################################################### +## 6. Мультиметоды +#################################################### + +# Все именованные функции являются generic-функциями, +# т.е. все они состоят из разных методов. +# Каждый конструктор типа Lion — это метод generic-функции Lion. + +# Приведём пример без использования конструкторов, создадим функцию meow + +# Определения Lion, Panther и Tiger +function meow(animal::Lion) + animal.roar # доступ к свойству типа через точку +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# Проверка +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# Вспомним иерархию типов +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# Определим функцию, принимающую на вход объекты типа Cat +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => выведет "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# В объектно-ориентированных языках распространена одиночная диспетчеризация — +# подходящий метод выбирается на основе типа первого аргумента. +# В Julia все аргументы участвуют в выборе нужного метода. + +# Чтобы понять разницу, определим функцию с несколькими аргументами. +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) # => выведет The orange tiger wins! + +# Переопределим поведение функции, если Cat-объект является Lion-объектом +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) # => выведет The green-maned lion wins! + +# Драться можно не только с тиграми! +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => выведет The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# Вообще, пускай кошачьи могут первыми проявлять агрессию +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# Предупреждение говорит, что неясно, какой из методов вызывать: +fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The victorious cat says rarrr +# Результат может оказаться разным в разных версиях Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The lions come to a tie + + +# Под капотом +# Язык позволяет посмотреть на сгенерированные ассемблерный и LLVM-код. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# Что происходит, когда мы передаём функции square_area целое число? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Вводная часть + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # + # imul RAX, RAX # + # pop RBP # + # ret # + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Произведение чисел одинарной точности (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Произведение чисел двойной точности (AVX) + # pop RBP + # ret + # +# Если хотя бы один из аргументов является числом с плавающей запятой, +# то Julia будет использовать соответствующие инструкции. +# Вычислим площать круга +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Загрузить целое число (r) + # movabs RAX, 4593140240 # Загрузить pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## Что дальше? + +Для более подробной информации читайте [документацию по языку](http://docs.julialang.org/en/latest/manual/) + +Если вам нужна помощь, задавайте вопросы в [списке рассылки](https://groups.google.com/forum/#!forum/julia-users). diff --git a/ru-ru/lua-ru.html.markdown b/ru-ru/lua-ru.html.markdown new file mode 100644 index 00000000..da9ced6a --- /dev/null +++ b/ru-ru/lua-ru.html.markdown @@ -0,0 +1,425 @@ +--- +language: Lua +filename: learnlua-ru.lua +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] +translators: + - ["Max Solomonov", "https://vk.com/solomonovmaksim"] + - ["Max Truhonin", "https://vk.com/maximmax42"] + - ["Konstantin Gromyko", "https://vk.com/id0x1765d79"] + - ["Stanislav Gromov", "https://vk.com/id156354391"] +lang: ru-ru +--- + +```lua +-- Два дефиса начинают однострочный комментарий. + +--[[ + Добавление двух квадратных скобок + делает комментарий многострочным. +--]] +-------------------------------------------------------------------------------- +-- 1. Переменные, циклы и условия. +-------------------------------------------------------------------------------- + +num = 42 -- Все числа имеют тип double. +-- Не волнуйтесь, в 64-битных double 52 бита +-- отведено под хранение целой части числа; +-- точность не является проблемой для +-- целочисленных значений, занимающих меньше 52 бит. + +s = 'walternate' -- Неизменные строки, как в Python. +t = "Двойные кавычки также приветствуются" +u = [[ Двойные квадратные скобки + начинают и заканчивают + многострочные значения.]] +t = nil -- Удаляет определение переменной t; в Lua есть сборка мусора. + +-- Блоки обозначаются ключевыми словами, такими как do/end: +while num < 50 do + num = num + 1 -- Операторов ++ и += нет. +end + +-- Ветвление "если": +if num > 40 then + print('больше 40') +elseif s ~= 'walternate' then -- ~= обозначает "не равно". + -- Проверка равенства это ==, как в Python; работает для строк. + io.write('не больше 40\n') -- По умолчанию вывод в stdout. +else + -- По умолчанию переменные являются глобальными. + thisIsGlobal = 5 -- Стиль CamelСase является общим. + + -- Как сделать переменную локальной: + local line = io.read() -- Считывает введённую строку. + + -- Для конкатенации строк используется оператор .. : + print('Зима пришла, ' .. line) +end + +-- Неопределённые переменные возвращают nil. +-- Этот пример не является ошибочным: +foo = anUnknownVariable -- Теперь foo = nil. + +aBoolValue = false + +-- Только значения nil и false являются ложными; 0 и '' являются истинными! +if not aBoolValue then print('это значение ложно') end + +-- Для 'or' и 'and' действует принцип "какой оператор дальше, +-- тот и применяется". Это действует аналогично оператору a?b:c в C/js: +ans = aBoolValue and 'yes' or 'no' --> 'no' + +karlSum = 0 +for i = 1, 100 do -- Здесь указан диапазон, ограниченный с двух сторон. + karlSum = karlSum + i +end + +-- Используйте "100, 1, -1" как нисходящий диапазон: +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- В основном, диапазон устроен так: начало, конец[, шаг]. + +-- Другая конструкция цикла: +repeat + print('путь будущего') + num = num - 1 +until num == 0 + +-------------------------------------------------------------------------------- +-- 2. Функции. +-------------------------------------------------------------------------------- + +function fib(n) + if n < 2 then return n end + return fib(n - 2) + fib(n - 1) +end + +-- Вложенные и анонимные функции являются нормой: +function adder(x) + -- Возращаемая функция создаётся, когда вызывается функция adder, + -- и запоминает значение переменной x: + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- Возвраты, вызовы функций и присвоения работают со списками, +-- которые могут иметь разную длину. +-- Лишние получатели принимают значение nil, а лишние значения игнорируются. + +x, y, z = 1, 2, 3, 4 +-- Теперь x = 1, y = 2, z = 3, а 4 просто отбрасывается. + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> выводит "zaphod nil nil" +-- Теперь x = 4, y = 8, а значения 15..42 отбрасываются. + +-- Функции могут быть локальными и глобальными. Эти строки делают одно и то же: +function f(x) return x * x end +f = function (x) return x * x end + +-- Эти тоже: +local function g(x) return math.sin(x) end +local g = function(x) return math.sin(x) end +-- Эквивалентно для local function g(x)..., однако ссылки на g +-- в теле функции не будут работать, как ожидалось. +local g; g = function (x) return math.sin(x) end +-- 'local g' будет прототипом функции. + +-- Кстати, тригонометрические функции работают с радианами. + +-- Вызов функции с одним строковым параметром не требует круглых скобок: +print 'hello' -- Работает без ошибок. + +-- Вызов функции с одним табличным параметром также +-- не требует круглых скобок (про таблицы в след. части): +print {} -- Тоже сработает. + +-------------------------------------------------------------------------------- +-- 3. Таблицы. +-------------------------------------------------------------------------------- + +-- Таблица = единственная составная структура данных в Lua; +-- представляет собой ассоциативный массив. +-- Подобно массивам в PHP или объектам в JS, они представляют собой +-- хеш-таблицы, которые также можно использовать в качестве списков. + + +-- Использование словарей: + +-- Литералы имеют ключ по умолчанию: +t = {key1 = 'value1', key2 = false} + +-- Строковые ключи используются, как в точечной нотации в JS: +print(t.key1) -- Печатает 'value1'. +t.newKey = {} -- Добавляет новую пару ключ/значение. +t.key2 = nil -- Удаляет key2 из таблицы. + +-- Литеральная нотация для любого значения ключа (кроме nil): +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- пишет "tau" + +-- Ключ соответствует значению для чисел и строк, но при +-- использовании таблицы в качестве ключа берётся её экземпляр. +a = u['@!#'] -- Теперь a = 'qbert'. +b = u[{}] -- Вы могли ожидать 1729, но получится nil: +-- b = nil, т.к. ключ не будет найден. +-- Это произойдёт потому, что за ключ мы использовали не тот же самый объект, +-- который был использован для сохранения оригинального значения. +-- Поэтому строки и числа удобнее использовать в качестве ключей. + +-- Вызов функции с одной таблицей в качестве аргумента +-- не требует круглых скобок: +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- Печатает 'Sonmi~451'. + +for key, val in pairs(u) do -- Цикл по таблице. + print(key, val) +end + +-- _G - это таблица со всеми глобалями. +print(_G['_G'] == _G) -- Печатает 'true'. + +-- Использование таблиц, как списков / массивов: + +-- Список значений с неявно заданными целочисленными ключами: +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v - размер списка v. + print(v[i]) -- Нумерация начинается с 1 !! +end + +-- Список не является отдельным типом. v - всего лишь таблица +-- с последовательными целочисленными ключами, воспринимаемая как список. + +-------------------------------------------------------------------------------- +-- 3.1 Метатаблицы и метаметоды. +-------------------------------------------------------------------------------- + +-- Таблицу можно связать с метатаблицей, задав ей поведение, как при +-- перегрузке операторов. Позже мы увидим, что метатаблицы поддерживают +-- поведение, как в js-прототипах. +f1 = {a = 1, b = 2} -- Представляет дробь a/b. +f2 = {a = 2, b = 3} + +-- Это не сработает: +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + local sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- вызвать __add(f1, f2) на метатаблице от f1 + +-- f1, f2 не имеют ключа для своих метатаблиц в отличии от прототипов в js, +-- нужно получить его через getmetatable(f1). Метатаблица - обычная таблица +-- поэтому с ключами, известными для Lua (например, __add). + +-- Но следущая строка будет ошибочной т.к в s нет метатаблицы: +-- t = s + s +-- Похожий на классы подход, приведенный ниже, поможет это исправить. + +-- __index перегружает в метатаблице просмотр через точку: +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- работает! спасибо, мета-таблица. + +-------------------------------------------------------------------------------- +-- При неудаче прямой табличный поиск попытается использовать +-- значение __index в метатаблице, причём это рекурсивно. + +-- Значение __index также может быть функцией +-- function(tbl, key) для настраиваемого поиска. + +-- Значения типа __index, __add, ... называются метаметодами. +-- Ниже приведён полный список метаметодов. + +-- __add(a, b) для a + b +-- __sub(a, b) для a - b +-- __mul(a, b) для a * b +-- __div(a, b) для a / b +-- __mod(a, b) для a % b +-- __pow(a, b) для a ^ b +-- __unm(a) для -a +-- __concat(a, b) для a .. b +-- __len(a) для #a +-- __eq(a, b) для a == b +-- __lt(a, b) для a < b +-- __le(a, b) для a <= b +-- __index(a, b) <функция или таблица> для a.b +-- __newindex(a, b, c) для a.b = c +-- __call(a, ...) для a(...) + +-------------------------------------------------------------------------------- +-- 3.2 Классоподобные таблицы и наследование. +-------------------------------------------------------------------------------- + +-- В Lua нет поддержки классов на уровне языка, +-- однако существуют разные способы их создания с помощью +-- таблиц и метатаблиц. + +-- Ниже приведён один из таких способов. + +Dog = {} -- 1. + +function Dog:new() -- 2. + local newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('I say ' .. self.sound) +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'I say woof' -- 8. + +-- 1. Dog похоже на класс, но на самом деле это таблица. +-- 2. "function tablename:fn(...)" - то же самое, что и +-- "function tablename.fn(self, ...)", просто : добавляет первый аргумент +-- перед собой. См. пункты 7 и 8, чтобы понять, как self получает значение. +-- 3. newObj - это экземпляр класса Dog. +-- 4. "self" - экземпляр класса. Зачастую self = Dog, но с помощью наследования +-- это можно изменить. newObj получит свои функции, когда мы установим +-- метатаблицу для newObj и __index для self на саму себя. +-- 5. Напоминание: setmetatable возвращает первый аргумент. +-- 6. : работает, как в пункте 2, но в этот раз мы ожидаем, +-- что self будет экземпляром, а не классом. +-- 7. То же самое, что и Dog.new(Dog), поэтому self = Dog в new(). +-- 8. То же самое, что mrDog.makeSound(mrDog); self = mrDog. +-------------------------------------------------------------------------------- + +-- Пример наследования: + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + local s = self.sound .. ' ' -- 2. + print(s .. s .. s) +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof' -- 4. + +-------------------------------------------------------------------------------- +-- 1. LoudDog получит методы и переменные класса Dog. +-- 2. В self будет ключ 'sound' из new(), см. пункт 3. +-- 3. То же самое, что и "LoudDog.new(LoudDog)", конвертированное +-- в "Dog.new(LoudDog)", поскольку в LoudDog нет ключа 'new', +-- но в его метатаблице есть "__index = Dog". +-- Результат: Метатаблицей для seymour стала LoudDog, +-- а "LoudDog.__index = Dog". Поэтому seymour.key будет равно +-- seymour.key, LoudDog.key, Dog.key, в зависимости от того, +-- какая таблица будет первой с заданным ключом. +-- 4. Ключ 'makeSound' находится в LoudDog; +-- то же самое, что и "LoudDog.makeSound(seymour)". + +-- При необходимости функция new() в подклассе +-- может быть похожа на аналог в базовом классе. +function LoudDog:new() + local newObj = {} + -- установить newObj + self.__index = self + return setmetatable(newObj, self) +end + +-------------------------------------------------------------------------------- +-- 4. Модули. +-------------------------------------------------------------------------------- + + +--[[ Я закомментировал этот раздел, чтобы остальная часть скрипта осталась +-- работоспособной. +``` + +```lua +-- Предположим, файл mod.lua будет выглядеть так: +local M = {} + +local function sayMyName() + print('Hrunkner') +end + +function M.sayHello() + print('Привет, ') + sayMyName() +end + +return M + +-- Другой файл может использовать функционал mod.lua: +local mod = require('mod') -- Запустим файл mod.lua. + +-- require - стандартный способ подключения модулей. +-- require ведёт себя так: (если не кэшировано, см. ниже) +local mod = (function () + <содержимое mod.lua> +end)() +-- Файл mod.lua воспринимается, как тело функции, поэтому +-- все локальные переменные и функции внутри него не видны за его пределами. + +-- Это работает, так как здесь mod = M в mod.lua: +mod.sayHello() -- Выведет "Привет, Hrunkner". + +-- Это будет ошибочным; sayMyName доступна только в mod.lua: +mod.sayMyName() -- ошибка + +-- Значения, возвращаемые require, кэшируются, +-- поэтому содержимое файла выполняется только 1 раз, +-- даже если он подключается с помощью require много раз. + +-- Предположим, mod2.lua содержит "print('Hi!')". +local a = require('mod2') -- Выведет "Hi!" +local b = require('mod2') -- Ничего не выведет; a=b. + +-- dofile, в отличии от require, работает без кэширования: +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (запустится снова) + +-- loadfile загружает файл, но не запускает его. +f = loadfile('mod2') -- Вызов f() запустит содержимое mod2.lua. + +-- loadstring - это loadfile для строк. +g = loadstring('print(343)') -- Вернет функцию. +g() -- Напишет 343. + +--]] + +``` +## Примечание (от автора) + +Мне было интересно изучить Lua, чтобы делать игры при помощи <a href="http://love2d.org/">игрового движка LÖVE</a>. + +Я начинал с <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>. +Затем я прочитал официальную <a href="http://www.lua.org/pil/contents.html">Документацию по Lua</a>. + +Также может быть полезной <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Краткая справка по Lua</a> на lua-users.org. + +Ещё из основных тем не охвачены стандартные библиотеки: + +* <a href="http://lua-users.org/wiki/StringLibraryTutorial">библиотека string</a> +* <a href="http://lua-users.org/wiki/TableLibraryTutorial">библиотека table</a> +* <a href="http://lua-users.org/wiki/MathLibraryTutorial">библиотека math</a> +* <a href="http://lua-users.org/wiki/IoLibraryTutorial">библиотека io</a> +* <a href="http://lua-users.org/wiki/OsLibraryTutorial">библиотека os</a> + +Кстати, весь файл написан на Lua; сохраните его как learn.lua и запустите при помощи "lua learn.lua" ! + +Изначально эта статья была написана для tylerneylon.com. +Также она доступна как <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Удачи с Lua! diff --git a/ru-ru/markdown-ru.html.markdown b/ru-ru/markdown-ru.html.markdown new file mode 100644 index 00000000..eb8e4881 --- /dev/null +++ b/ru-ru/markdown-ru.html.markdown @@ -0,0 +1,279 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] + - ["Pirogov Alexey", "http://twitter.com/alex_pir"] +filename: markdown-ru.md +lang: ru-ru +--- + +Язык разметки Markdown создан Джоном Грубером (англ. John Gruber) +и Аароном Шварцем (англ. Aaron H. Swartz) в 2004 году. +Авторы задавались целью создать максимально удобочитаемый +и удобный в публикации облегчённый язык разметки, +пригодный для последующего преобразования в HTML +(а также и в другие форматы). + + ```markdown +<!-- Markdown является надмножеством HTML, поэтому любой HTML-файл является +валидным документом Markdown, что позволяет использовать напрямую +любые элементы HTML-разметки, такие, например, как этот комментарий. + Встроенные в документ HTML-элементы не затрагиваются парсером Markdown +и попадают в итоговый HTML без изменений. Однако, следует понимать, +что эта же особенность не позволяет использовать разметку Markdown внутри +HTML-элементов --> + +<!-- Ещё одна особенность формата Markdown состоит в том, что поддерживаемые +возможности разметки зависят от конкретной реализации парсера. В данном +руководстве возможности, поддерживаемые лишь определёнными парсерами, +сопровождаются соответствующими примечаниями. --> + +<!-- Заголовки --> + +<!-- HTML-элементы от <h1> до <h6> размечаются очень просто: +текст, который должен стать заголовком, предваряется +соответствующим количеством символов "#": --> +# Это заголовок h1 +## Это заголовок h2 +### Это заголовок h3 +#### Это заголовок h4 +##### Это заголовок h5 +###### Это заголовок h6 + +<!-- Markdown позволяет размечать заголовки <h1> и <h2> ещё одним способом: --> +Это заголовок h1 +================ + +А это заголовок h2 +------------------ + +<!-- Простейшая стилизация текста --> + +<!-- Текст легко сделать полужирным и/или курсивным: --> + +*Этот текст будет выведен курсивом.* +_Так же, как этот._ + +**А этот текст будет полужирным.** +__И этот тоже.__ + +***Полужирный курсив.*** +**_И тут!_** +*__И даже здесь!__* + +<!-- В Github Flavored Markdown (версии Markdown, использующейся в Github, +для рендеринга Markdown-документов) текст можно сделать зачёркнутым: --> + +~~Зачёркнутый текст.~~ + +<!-- Абзацами являются любые строки, следующие друг за другом. +Разделяются же абзацы одной или несколькими пустыми строками: --> + +Это абзац. Всё предельно просто. + +А тут уже параграф №2. +Эта строка всё ещё относится к параграфу №2! + + +О, а вот это уже параграф №3! + +<!-- Для вставки принудительных переносов можно использовать HTML-тэг <br/>: --> + +Принудительный <br/> перенос! + +<!-- Цитаты размечаются с помощью символа ">": --> + +> Это цитата. В цитатах можно +> принудительно переносить строки, вставляя ">" в начало каждой следующей строки. А можно просто оставлять достаточно длинными, и такие длинные строки будут перенесены автоматически. +> Разницы между этими двумя подходами к переносу строк нет, коль скоро +> каждая строка начинается с символа ">" + +> А ещё цитаты могут быть многоуровневыми: +>> как здесь +>>> и здесь :) +> Неплохо? + +<!-- Списки --> +<!-- Маркированные списки размечаются вставкой в начало каждого элемента +одного из символов "*", "+" или "-": +(символ должен быть одним и тем же для всех элементов) --> + +* Список, +* Размеченный +* Звёздочками + +либо + ++ Список, ++ Размеченный ++ Плюсами + +либо + +- Список, +- Размеченный +- Дефисами + +<!-- В нумерованных списках каждая строка начинается +с числа и точки вслед за ним: --> + +1. Первый элемент +2. Второй элемент +3. Третий элемент + +<!-- Заметьте, нумеровать элементы корректно необязательно. Достаточно указать +любое число в начале каждого элемента и рендер пронумерует элементы сам! +Правда, злоупотреблять этим не стоит :) --> + +1. Первый элемент +1. Второй элемент +1. Третий элемент +<!-- (Этот список будет отрендерен так же, как и предыдущий!) --> + +<!-- Списки могут быть вложенными: --> + +1. Введение +2. Начало работы +3. Примеры использования + * Простые + * Сложные +4. Заключение + +<!-- Блоки с исходным кодом --> +<!-- Фрагменты исходного кода выделяются очень просто - каждая строка блока должна иметь отступ в четыре пробела либо в один символ табуляции --> + + Это код, + причём - многострочный + +<!-- Дополнительные отступы в коде следует делать с помощью четырёх пробелов: --> + + my_array.each do |item| + puts item + end + +<!-- Иногда бывает нужно вставить фрагмент кода прямо в строку текста, +не выделяя код в блок. Для этого фрагменты кода нужно обрамлять +символами "`": --> + +Например, можно выделить имя функции `go_to()` прямо посреди текста. + +<!-- Github Flavored Markdown позволяет указать для блока кода синтаксис оного. +В этом случае синтаксис внутри блока будет подсвечен. Пример: --> + +\`\`\`ruby <!-- Только нужно будет убрать символы "\", оставив лишь "```ruby" --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- И здесь тоже backslashes нужно убрать, т.е. оставить "```" --> + +<-- Обратите внимание: фрагмент, указанный выше, не предваряется отступами, +поскольку Github сам в состоянии определить границы блока - по строкам "```" --> + +<!-- Горизонтальный разделитель (<hr />) --> +<!-- Разделители добавляются вставкой строки из трёх и более +(одинаковых) символов "*" или "-": --> + +*** +--- +- - - <!-- между символами допустимы пробелы --> +**************** + +<!-- Ссылки --> +<!-- Одной из сильных сторон Markdown можно смело считать то, +как просто размечаются гиперссылки. Для создания ссылки укажите +текст ссылки, заключив его в квадратные скобки, +и сразу после - url, заключенный в "круглые" --> + +[Ссылка!](http://test.com/) + +<!-- Также для ссылки можно указать всплывающую подсказку: --> + +[Ссылка!](http://test.com/ "Ссылка на Test.com") + +<!-- В url можно использовать относительные пути: --> + +[Перейти к музыке](/music/). + +<!-- Markdown позволяет размечать ссылку в виде сноски: --> + +[Здесь][link1] высможете узнать больше! +А можно кликнуть [сюда][foobar], если очень хочется. + +<!-- где-нибудь внизу --> +[link1]: http://test.com/ "Круто!" +[foobar]: http://foobar.biz/ "Тоже хорошо!" + +<!-- Примечания: +- Подсказка может быть заключена в одинарные кавычки вместо двойных, + а также в круглые скобки. +- Сноска может находиться в любом месте документа и может иметь +идентификатор (далее ID) произвольной длины, +лишь бы это ID был уникальным. --> + +<!-- Также при разметке ссылок-сносок можно опустить ID, +если текст ссылки уникален в пределах документа: --> + +Ссылка на [Google][]. + +[google]: http://google.com/ + +<!-- Правда, эта возможность не очень распространена. --> + +<!-- Изображения --> +<!-- Разметка изображений очень похожа на разметку ссылок. +Нужно всего лишь добавить "!" перед ссылкой! --> + + + +<!-- Изображения тоже могут быть оформлены, как сноски: --> + +![Альтернативный текст][myimage] + +![То же изображение ещё раз][myimage] + +[myimage]: relative/urls/cool/image.jpg "подсказка" + +<!-- Ещё немного ссылок: --> +<!-- Автоссылки --> + +Ссылка вида <http://testwebsite.com/> эквивалентна +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Автоссылки для адресов электронной почты --> + +<foo@bar.com> + +<!-- Экранирование символов --> + +<!-- Может потребоваться вставить спецсимвол в текст "как есть", +т.е. защитить его от обработки парсером. +Такой символ должен быть "экранирован" с помощью обратной косой черты +(символа "\"): --> + +\*текст, заключённый в звёздочки!\* + +<!-- Таблицы --> +<!-- Таблицы официально поддерживаются только в Github Flavored Markdown, +да и синтаксис имеют не слишком удобный. +Но если очень нужно, размечайте таблицы так: --> + +| Столбец 1 | Столбец 2 | Столбец 3 | +| :----------- | :----------: | -----------: | +| Выравнивание | Выравнивание | Выравнивание | +| влево | по центру | вправо | + +<!-- Или более компактно --> + +Колонка 1|Колонка 2|Колонка 3 +:--|:-:|--: +Выглядит|это|страшновато... + +<!-- Ну вот и всё! --> + +``` + +За более подробной информацией обращайтесь к [статье](http://daringfireball.net/projects/markdown/syntax) Джона Грубера о синтаксисе Markdown. + +Также часто бывает полезной отличная ["шпаргалка"](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) по Markdown от Adam Pritchard. + +Если вдруг встретите ошибки в переводе или же захотите его дополнить, делайте pull requests - авторы всегда рады обратной связи! diff --git a/ru-ru/objective-c-ru.html.markdown b/ru-ru/objective-c-ru.html.markdown new file mode 100644 index 00000000..ddff2e5c --- /dev/null +++ b/ru-ru/objective-c-ru.html.markdown @@ -0,0 +1,819 @@ +--- +language: Objective-C +filename: LearnObjectiveC-ru.m +contributors: + - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] + - ["Yannick Loriot", "https://github.com/YannickL"] + - ["Levi Bostian", "https://github.com/levibostian"] +translators: + - ["Evlogy Sutormin", "http://evlogii.com"] + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +Objective-C — основной язык программирования, используемый корпорацией Apple +для операционных систем OS X и iOS и их соответствующих фреймворках Cocoa и +Cocoa Touch. +Он является объектно-ориентированным языком программирования общего назначения, +который добавляет обмен сообщениями в Smalltalk-стиле к языку программирования C. + +```objective_c +// Однострочные комментарии начинаются с // + +/* +Так выглядят многострочные комментарии +*/ + +// Импорт заголовочных файлов фреймворка Foundation с помощью #import +// Используйте <>, чтобы импортировать глобальные файлы (обычно фреймворки) +// Используйте "", чтобы импортировать локальные файлы (из проекта) +#import <Foundation/Foundation.h> +#import "MyClass.h" + +// Если вы включили модули для iOS >= 7.0 или OS X >= 10.9 проектов в +// Xcode 5, вы можете импортировать фреймворки подобным образом: +@import Foundation; + +// Точка входа в программу - это функция main, +// которая возвращает целый тип +int main (int argc, const char * argv[]) +{ + // Создание autorelease pool для управления памятью в программе + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + // В место этого воспользуйтесь @autoreleasepool, если вы используете + // автоматический подсчет ссылок (ARC) + @autoreleasepool { + + // Используйте NSLog для печати в консоль + NSLog(@"Привет Мир!"); // Напечатает строку "Привет Мир!" + + /////////////////////////////////////// + // Типы и переменные + /////////////////////////////////////// + + // Объявление простых типов + int myPrimitive1 = 1; + long myPrimitive2 = 234554664565; + + // Объявление объектов + // Помещайте * в начало названия объекта для строго типизированного объявления + MyClass *myObject1 = nil; // Строгая типизация + id myObject2 = nil; // Слабая типизация + // %@ – это объект + // 'description' - это общий для всех объектов метод вывода данных + NSLog(@"%@ and %@", myObject1, [myObject2 description]); // напечатает "(null) and (null)" + + // Строка + NSString *worldString = @"Мир"; + NSLog(@"Привет %@!", worldString); // напечатает "Привет Мир!" + // NSMutableString - это изменяемая версия NSString-объекта + NSMutableString *mutableString = [NSMutableString stringWithString:@"Привет"]; + [mutableString appendString:@" Мир!"]; + NSLog(@"%@", mutableString); // напечатает => "Привет Мир!" + + // Символьные литералы + NSNumber *theLetterZNumber = @'Z'; + char theLetterZ = [theLetterZNumber charValue]; // или 'Z' + NSLog(@"%c", theLetterZ); + + // Целочисленные литералы + NSNumber *fortyTwoNumber = @42; + int fortyTwo = [fortyTwoNumber intValue]; // или '42' + NSLog(@"%i", fortyTwo); + + // Беззнаковый целочисленный литерал + NSNumber *fortyTwoUnsignedNumber = @42U; + unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // или 42 + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42]; + short fortyTwoShort = [fortyTwoShortNumber shortValue]; // или 42 + NSLog(@"%hi", fortyTwoShort); + + NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41]; + unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // или 41 + NSLog(@"%u", fortyOneUnsigned); + + NSNumber *fortyTwoLongNumber = @42L; + long fortyTwoLong = [fortyTwoLongNumber longValue]; // или 42 + NSLog(@"%li", fortyTwoLong); + + NSNumber *fiftyThreeLongNumber = @53L; + unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // или 53 + NSLog(@"%lu", fiftyThreeUnsigned); + + // Вещественный литерал + NSNumber *piFloatNumber = @3.141592654F; + float piFloat = [piFloatNumber floatValue]; // или 3.141592654f + NSLog(@"%f", piFloat); // напечатает 3.141592654 + NSLog(@"%5.2f", piFloat); // напечатает " 3.14" + + NSNumber *piDoubleNumber = @3.1415926535; + double piDouble = [piDoubleNumber doubleValue]; // или 3.1415926535 + NSLog(@"%f", piDouble); + NSLog(@"%4.2f", piDouble); // напечатает "3.14" + + // NSDecimalNumber - это класс с фиксированной точкой, который является + // более точным, чем float или double + NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"]; + NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"]; + // NSDecimalNumber не способен использовать стандартные +, -, *, / операторы, + // поэтому он предоставляет свои собственные: + [oneDecNum decimalNumberByAdding:twoDecNum]; + [oneDecNum decimalNumberBySubtracting:twoDecNum]; + [oneDecNum decimalNumberByMultiplyingBy:twoDecNum]; + [oneDecNum decimalNumberByDividingBy:twoDecNum]; + NSLog(@"%@", oneDecNum); // напечатает "10.99", т.к. NSDecimalNumber - изменяемый + + // BOOL (булевый) литерал + NSNumber *yesNumber = @YES; + NSNumber *noNumber = @NO; + // или + BOOL yesBool = YES; + BOOL noBool = NO; + NSLog(@"%i", yesBool); // напечатает 1 + + // Массив + // Может содержать различные типы данных, но должен быть объектом Objective-C + NSArray *anArray = @[@1, @2, @3, @4]; + NSNumber *thirdNumber = anArray[2]; + NSLog(@"Третье число = %@", thirdNumber); // Напечатает "Третье число = 3" + // NSMutableArray - это изменяемая версия NSArray, допускающая вам изменять + // элементы в массиве и расширять или сокращать массив. + // Удобный, но не эффективный как NSArray. + NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2]; + [mutableArray addObject:@"Привет"]; + [mutableArray addObject:@"Мир"]; + [mutableArray removeObjectAtIndex:0]; + NSLog(@"%@", [mutableArray objectAtIndex:0]); // напечатает "Мир" + + // Словарь + NSDictionary *aDictionary = @{ @"ключ1" : @"значение1", @"ключ2" : @"значение2" }; + NSObject *valueObject = aDictionary[@"Ключ"]; + NSLog(@"Объект = %@", valueObject); // Напечатает "Объект = (null)" + // NSMutableDictionary тоже доступен, как изменяемый словарь + NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2]; + [mutableDictionary setObject:@"значение1" forKey:@"ключ1"]; + [mutableDictionary setObject:@"значение2" forKey:@"ключ2"]; + [mutableDictionary removeObjectForKey:@"ключ1"]; + + // Множество + NSSet *set = [NSSet setWithObjects:@"Привет", @"Привет", @"Мир", nil]; + NSLog(@"%@", set); // напечатает {(Hello, World)} (порядок может отличаться) + // NSMutableSet тоже доступен, как изменяемое множество + NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2]; + [mutableSet addObject:@"Привет"]; + [mutableSet addObject:@"Привет"]; + NSLog(@"%@", mutableSet); // напечатает => {(Привет)} + + /////////////////////////////////////// + // Операторы + /////////////////////////////////////// + + // Операторы работают также как в Си. + // Например: + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (НЕТ) + 3 != 2; // => 1 (ДА) + 1 && 1; // => 1 (логическое И) + 0 || 1; // => 1 (логическое ИЛИ) + ~0x0F; // => 0xF0 (побитовое отрицание) + 0x0F & 0xF0; // => 0x00 (побитовое И) + 0x01 << 1; // => 0x02 (побитовый сдвиг влево (на 1)) + + /////////////////////////////////////// + // Структуры ветвления + /////////////////////////////////////// + + // Условный оператор + if (NO) + { + NSLog(@"Я никогда не выполнюсь"); + } else if (0) + { + NSLog(@"Я тоже никогда не выполнюсь"); + } else + { + NSLog(@"Я напечатаюсь"); + } + + // Ветвление с множественным выбором + switch (2) + { + case 0: + { + NSLog(@"Я никогда не выполнюсь"); + } break; + case 1: + { + NSLog(@"Я тоже никогда не выполнюсь"); + } break; + default: + { + NSLog(@"Я напечатаюсь"); + } break; + } + + // Цикл с предусловием + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++ инкрементирует ii после передачи значения + } // => напечатает "0," + // "1," + // "2," + // "3," + + // Цикл со счётчиком + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj); + } // => напечатает "0," + // "1," + // "2," + // "3," + + // Цикл просмотра + NSArray *values = @[@0, @1, @2, @3]; + for (NSNumber *value in values) + { + NSLog(@"%@,", value); + } // => напечатает "0," + // "1," + // "2," + // "3," + + // Цикл for для объектов. Может использоваться с любым объектом Objective-C + for (id item in values) { + NSLog(@"%@,", item); + } // напечатает => "0," + // "1," + // "2," + // "3," + + // Обработка исключений + @try + { + // Ваше исключение здесь + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"Файл не найден в системе" userInfo:nil]; + } @catch (NSException * e) + { + NSLog(@"Исключение: %@", e); + } @finally + { + NSLog(@"В конце отводится время для очистки."); + } // => напечатает "Исключение: Файл не найден в системе" + // "В конце отводится время для очистки." + + // NSError - это полезные объекты для аргументов функции, чтобы заполнить их + // пользовательскими ошибками. + NSError *error = [NSError errorWithDomain:@"Неправильный эл. адрес." code:4 userInfo:nil]; + + /////////////////////////////////////// + // Объекты + /////////////////////////////////////// + + // Создание объектов через выделение памяти и инициализацию. + // Объект не является полнофункциональным пока обе части не выполнятся. + MyClass *myObject = [[MyClass alloc] init]; + + // В Objective-C модель ООП базируется на передаче сообщений. + // В Objective-C Вы не просто вызваете метод; вы посылаете сообщение. + [myObject instanceMethodWithParameter:@"Стив Джобс"]; + + // Очищайте память, перед завершением работы программы. + [pool drain]; + + // Конец @autoreleasepool + } + + // Конец программы. + return 0; +} + +/////////////////////////////////////// +// Классы и функции +/////////////////////////////////////// + +// Объявляйте свой класс в файле МойКласс.h +// Синтаксис объявления: +// @interface ИмяКласса : ИмяКлассаРодителя <ИмплементируемыеПротоколы> +// { +// тип имя; <= Объявление переменных; +// } +// @property тип имя; <= объявление свойств +// -/+ (тип) Объявление метода(ов). +// @end +@interface MyClass : NSObject <MyProtocol> // NSObject - это базовый класс в Objective-C. +{ + // Объявления экземпляров переменных (может существовать в файлах интерфейса или реализвации) + int count; // По умолчанию защищенный доступ. + @private id data; // Приватный доступ (Намного удобнее объявлять в файле реализации) + NSString *name; +} +// Удобное обозначение для переменных с открытым (public) доступом +// автоматически генерируется сеттер-метод +// По умолчанию название сеттер-метода начинается с 'set' с последующим именем +// переменной из @property +@property int propInt; // Имя сеттер-метода = 'setPropInt' +@property (copy) id copyId; // (copy) => Скопировать объект в ходе присвоения. +// (readonly) => Не позволяет установить значение вне @interface +@property (readonly) NSString *roString; // Используйте @synthesize + // в @implementation, чтобы создать аксессор +// Вы можете настроить геттер и сеттер имена вместо используемого 'set'-имени по умолчанию: +@property (getter=lengthGet, setter=lengthSet:) int length; + +// Методы ++/- (возвращаемый тип)сигнатураМетода:(Параметр типа *)имяПараметра; + +// + для методов класса ++ (NSString *)classMethod; ++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight; + +// - для методов объекта +- (NSString *)instanceMethodWithParameter:(NSString *)string; +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number; + +// Методы-конструктор с аргументом: +- (id)initWithDistance:(int)defaultDistance; +// В Objective-C имена методов очень описательные. Всегда имена методов соответствуют своим аргументам + +@end // Устанавливает конец интерфейса (interface) + + +// Чтобы обратиться к открытым (public) переменным из файла реализации, @property генерирует сеттер-метод +// автоматически. Название метода - это 'set' с последующим именем переменной из @property: +MyClass *myClass = [[MyClass alloc] init]; // создает экземпляр объекта класса MyClass +[myClass setCount:10]; +NSLog(@"%d", [myClass count]); // напечатает => 10 +// Или используйте свой геттер и сеттер методы, которые определены в @interface: +[myClass lengthSet:32]; +NSLog(@"%i", [myClass lengthGet]); // напечатает => 32 +// Для удобства вы можете использовать точечную нотацию, +// чтобы установить и получить доступ к переменным объекта: +myClass.count = 45; +NSLog(@"%i", myClass.count); // напечатает => 45 + +// Вызов методов класса: +NSString *classMethodString = [MyClass classMethod]; +MyClass *classFromName = [MyClass myClassFromName:@"Привет"]; + +// Вызов методов экземпляра: +MyClass *myClass = [[MyClass alloc] init]; // Создает экземпляр объекта MyClass +NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Привет"]; + +// Селекторы +// Это способ динамически представить методы. Используйте для вызова методов класса, передайте методы +// через функции, чтобы сказать другим классам, что они должны вызвать их и сохранить методы +// как переменные +// SEL - это тип данных. @selector() вернет селектор из предоставленного имени метода +// methodAParameterAsString:andAParameterAsNumber: - это название метода в MyClass +SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:); +if ([myClass respondsToSelector:selectorVar]) { // Проверяет содержит ли класс метод + // Необходимо установить все аргументы метода в один объект, что отправить его в performSelector-функцию + NSArray *arguments = [NSArray arrayWithObjects:@"Привет", @4, nil]; + [myClass performSelector:selectorVar withObject:arguments]; // Вызывает метод +} else { + // NSStringFromSelector() вернет NSString название метода полученного селектором + NSLog(@"MyClass не содержит метод: %@", NSStringFromSelector(selectedVar)); +} + +// Имплементируйте методы в файле МойКласс.m: +@implementation MyClass { + long distance; // Переменная экземпляра с закрытым (private) доступом + NSNumber height; +} + +// To access a public variable from the interface file, use '_' followed by variable name: +_count = 5; // References "int count" from MyClass interface +// Access variables defined in implementation file: +distance = 18; // References "long distance" from MyClass implementation +// To use @property variable in implementation, use @synthesize to create accessor variable: +@synthesize roString = _roString; // _roString available now in @implementation + +// Called before calling any class methods or instantiating any objects ++ (void)initialize +{ + if (self == [MyClass class]) { + distance = 0; + } +} + +// Вызывается при высвобождении памяти под объектом +- (void)dealloc +{ + [height release]; // Если не используется ARC, убедитесь в освобождении переменных объекта класса + [super dealloc]; // and call parent class dealloc +} + +// Конструкторы – это способ создания объектов класса. +// Это конструктор по умолчанию, который вызывается, когда объект инициализируется. +- (id)init +{ + if ((self = [super init])) // 'super' используется для того, чтобы обратиться к методам родительского класса + { + self.count = 1; // 'self' используется для вызова самого себя + } + return self; +} +// Можно создать конструкторы, которые содержат аргументы: +- (id)initWithDistance:(int)defaultDistance +{ + distance = defaultDistance; + return self; +} + ++ (NSString *)classMethod +{ + return [[self alloc] init]; +} + ++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight +{ + height = defaultHeight; + return [[self alloc] init]; +} + +- (NSString *)instanceMethodWithParameter:(NSString *)string +{ + return @"Новая строка"; +} + +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number +{ + return @42; +} + +// Objective-C не содержит объявление приватных методов, но вы можете имитировать их. +// Чтобы сымитировать приватный метод, создайте метод в @implementation, но не в @interface. +- (NSNumber *)secretPrivateMethod { + return @72; +} +[self secretPrivateMethod]; // Вызывает приватный метод + +// Методы объявленные в МyProtocol (см. далее) +- (void)myProtocolMethod +{ + // операторы +} + +@end // Устанавливает конец реализации (implementation) + +/////////////////////////////////////// +// Категории +/////////////////////////////////////// +// Категория - это группа методов предназначенные для того, чтобы расширить класс. Они позволяют вам добавить новые методы +// к существующему классу для организационных целей. Это не стоит путать с подклассами. +// Подклассы предназначены для ИЗМЕНЕНИЯ функциональности объекта пока как категории ДОБАВЛЯЮТ +// функциональность в объект. +// Категории позволяют вам: +// -- Добавлять методы в существующий класс для организационных целей. +// -- Допускает вам расширять объекты Objective-C классов (напр.: NSString) добавить ваши собственные методы. +// -- Добавляет возможность создать защищенные и закрытые методы классов. +// ПРИМЕЧАНИЕ: Не переопределяйте методы базового класса в категории даже если у вас есть возможность это сделать +// to. Переопределение методов может привести к ошибкам компиляции позднее между различными категориями и это +// нарушает цель категорий, чтобы добавлять только функциональность. Вместо этого подклассы переопределяют методы. + +// Здесь простой базовый класс Car. +@interface Car : NSObject + +@property NSString *make; +@property NSString *color; + +- (void)turnOn; +- (void)accelerate; + +@end + +// И реализация базового класса Car: +#import "Car.h" + +@implementation Car + +@synthesize make = _make; +@synthesize color = _color; + +- (void)turnOn { + NSLog(@"Машина заведена."); +} +- (void)accelerate { + NSLog(@"Ускорение."); +} + +@end + +// Теперь, если мы хотели создать грузовой объект, мы должны вместо создания подкласса класса Car, как это будет +// изменять функциональность Car чтобы вести себя подобно грузовику. Но давайте посмотрим, если мы хотим только добавить +// функциональность в существующий Car. Хороший пример должен быть чистить автомобиль. Итак мы создадим +// категорию для добавления его очистительных методов: +// @interface ИмяФайла: Car+Clean.h (ИмяБазовогоКласса+ИмяКатегории.h) +#import "Car.h" // Убедитесь в том, что базовый класс импортирован для расширения. + +@interface Car (Clean) // Имя категории внутри (), следующие после имени базового класса. + +- (void)washWindows; // Названия новых методов, которые мы добавляем в наш объект Car. +- (void)wax; + +@end + +// @implementation имя файла: Car+Clean.m (ИмяБазовогоКласса+ИмяКатегории.m) +#import "Car+Clean.h" // Импортируйте Очистку файл @interface категории. + +@implementation Car (Clean) + +- (void)washWindows { + NSLog(@"Окна промыли."); +} +- (void)wax { + NSLog(@"Воском натерли."); +} + +@end + +// Любой экземпляр объекта Car имеет возможность воспользоваться категорией. Все, что нужно сделать, это импортировать ее: +#import "Car+Clean.h" // Импортировать как множество различных категорий, как вы хотите использовать. +#import "Car.h" // Кроме того, необходимо импортировать базовый класс для использования его оригинальные функциональные возможности. + +int main (int argc, const char * argv[]) { + @autoreleasepool { + Car *mustang = [[Car alloc] init]; + mustang.color = @"Красный"; + mustang.make = @"Форд"; + + [mustang turnOn]; // Используйте методы из базового класса Car. + [mustang washWindows]; // Используйте методы категории Clean из класса Car. + } + return 0; +} + +// Objective-C не поддерживает объявление защищенных методов, но вы можете имитировать их. +// Создайте категорию, содержащую все защищенные методы, затем импортируйте ее только в +// @implementation-файле класса, относящегося к классу Car: +@interface Car (Protected) // Наименование категории с помощью 'Protected' +// дает знать, что методы защищенные. + +- (void)lockCar; // Здесь перечисляются методы, которые должны быть созданы +// только с помощью объектов класса Car. + +@end +// Чтобы воспользоваться защищенными методами, импортируйте категорию, затем реализуйте методы: +#import "Car+Protected.h" // Запомните, делайте импорт только в файле с @implementation. + +@implementation Car + +- (void)lockCar { + NSLog(@"Машина закрыта."); // Экземпляры класса Car не могут использовать +// метод lockCar, потому что он объявлен не в @interface. +} + +@end + +/////////////////////////////////////// +// Расширения +/////////////////////////////////////// +// Расширения позволяют вам переопределять атрибуты свойств и методов +// с открытым доступом в @interface. +// @interface имя файла: Shape.h +@interface Shape : NSObject // Расширение базового класса Shape переопределяет + // свои поля ниже. + +@property (readonly) NSNumber *numOfSides; + +- (int)getNumOfSides; + +@end +// Вы можете переопределить numOfSides-переменную или getNumOfSides-метод +// Внесение изменений с помощью расширения делается следующим образом: +// @implementation имя файла: Shape.m +#import "Shape.h" +// Расширения "живут" в том же файле, где и @implementation класса. +@interface Shape () // После имени базового класса скобки () объявляют расширение. + +@property (copy) NSNumber *numOfSides; // Делает numOfSides-свойство + // копирующим (copy) вместо свойства только для чтения (readonly). +-(NSNumber)getNumOfSides; // Изменяет метод getNumOfSides так, + // чтобы он возвращал объект NSNumber вместо типа int. +-(void)privateMethod; // Вы также можете создать новый закрытый метод + // внутри расширения. + +@end +// Главный @implementation: +@implementation Shape + +@synthesize numOfSides = _numOfSides; + +-(NSNumber)getNumOfSides { // Все операторы внутри расширения + // должны быть в @implementation. + return _numOfSides; +} +-(void)privateMethod { + NSLog(@"Закрытый метод созданный с помощью расширения."); + NSLog(@"Экземпляр Shape не может вызвать этот метод."); +} + +@end + +/////////////////////////////////////// +// Протоколы +/////////////////////////////////////// +// Протокол объявляет методы, которые могут быть реализованы с помощью +// любого класса. Протоколы сами по себе не являются классами. Они просто +// определяют интерфейс, который должен быть реализован другими объектами. +// @protocol имя файла: "CarUtilities.h" +@protocol CarUtilities <NSObject> // <NSObject> => Имя другого протокола, +// который включен в этот протокол. + @property BOOL engineOn; // Адаптирующий класс должен определить +// все @synthesize для @property и + - (void)turnOnEngine; // определить все методы. +@end +// Ниже пример класса, реализующий протокол. +#import "CarUtilities.h" // Импорт файла с @protocol. + +@interface Car : NSObject <CarUtilities> // Внутри <> имя протокола +// Здесь вам не нужно указывать @property или имена методов для CarUtilities. +// Они нужны только для @implementation. +- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // Вы также можете +// указать тип протоколов. +@end +// В @implementation нужно реализовать все @property и методы для протокола. +@implementation Car : NSObject <CarUtilities> + +@synthesize engineOn = _engineOn; // Создайте @synthesize-оператор +// для "@property engineOn". + +- (void)turnOnEngine { // Реализуйте turnOnEngine как вам угодно. Протоколы +// не определят, + _engineOn = YES; // как вам реализовать метод, он только требует, +// чтобы вы реализовали его. +} +// Вы можете использовать протокол как данные, если вы знаете, что он реализует +// методы и переменные. +- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind { + [objectOfSomeKind engineOn]; // У вас есть доступ к переменным объекта + [objectOfSomeKind turnOnEngine]; // и методам. + [objectOfSomeKind engineOn]; // Может или не может быть значение YES. Класс +// реализует как нужно. +} + +@end +// Экземпляры класса Car сейчас имеют доступ к протоколу. +Car *carInstance = [[Car alloc] init]; +[carInstance setEngineOn:NO]; +[carInstance turnOnEngine]; +if ([carInstance engineOn]) { + NSLog(@"Двигатель запущен."); // напечатает => "Двигатель запущен." +} +// Убедитись в том, что объект типа 'id' реализует протокол перед вызовом методов протокола: +if ([myClass conformsToProtocol:@protocol(CarUtilities)]) { + NSLog(@"Не работает, т.к. класс MyClass не реализует протокол CarUtilities."); +} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) { + NSLog(@"Работает как класс Car, который реализует протокол CarUtilities."); +} +// Категории тоже могут реализовать протоколы: +// @interface Car (CarCategory) <CarUtilities> +// Вы можете реализовать много протоколов: +// @interface Car : NSObject <CarUtilities, CarCleaning> +// ЗАМЕЧАНИЕ: Если два или более протоколов полагаются друг на друга, +// убедитесь, что они ранее объявлены: +#import "Brother.h" + +@protocol Brother; // Оператор раннего объявления. Без него компилятор +// выдаст ошибку. + +@protocol Sister <NSObject> + +- (void)beNiceToBrother:(id <Brother>)brother; + +@end + +// Рассмотрите проблему, где протокол Sister полагается на протокол Brother, +// а Brother полагается на Sister. +#import "Sister.h" + +@protocol Sister; // Эти строки предотвращают рекурсию, решая этим проблему. + +@protocol Brother <NSObject> + +- (void)beNiceToSister:(id <Sister>)sister; + +@end + + +/////////////////////////////////////// +// Блоки +/////////////////////////////////////// +// Блоки - это операторы кода, наподобие функции, которую возможно использовать +// как данные. +// Ниже простой блок с целочисленным аргументом, и возвращает аргумент плюс 4. +int (^addUp)(int n); // Объявите переменную, чтобы сохранить блок. +void (^noParameterBlockVar)(void); // Пример объявления блока-переменной +// без аргументов. +// Блоки имею доступ к переменным в той же области видимости. Но переменные +// будут только для чтения, и значения переданных в блок станут значением +// переменной, когда блок создастся. +int outsideVar = 17; // Если мы редактируем outsideVar после объявления addUp, +// outsideVar остается равным 17. +__block long mutableVar = 3; // __block делают переменные перезаписываемыми +// в блоках, в отличие от outsideVar. +addUp = ^(int n) { // Удалите (int n) в блоке, чтобы не принимать +// какие-либо параметры. + NSLog(@"Вы можете иметь столько строк в блоке, сколько вы хотели."); + NSSet *blockSet; // Также вы можете объявить локальные переменные. + mutableVar = 32; // Присвоить новое значение к __block-переменной. + return n + outsideVar; // Необязательный оператор возврата. +} +int addUp = add(10 + 16); // Вызывает блок кода с аргументами. +// Блоки часто используются как аргументы функции, чтобы позже их вызвать, или +// как функции обратного вызова (callbacks). +@implementation BlockExample : NSObject + +- (void)runBlock:(void (^)(NSString))block { + NSLog(@"В аргументе блок ничего не возвращает и принимает NSString-объект."); + block(@"Аргумент передан блоку на исполнение."); // Вызов блока. +} + +@end + + +/////////////////////////////////////// +// Управление памятью +/////////////////////////////////////// +/* +Для каждого объекта, используемого в приложении, должна быть выделена память +для таких объектов. Когда приложение прекращает использование объекта, память +должна быть освобождена, чтобы гарантировать эффективность приложения. +Objective-C не использует сборщик мусора, а вместо этого применяет подсчет ссылок. +Пока существует по крайней мере одна ссылка на объект (также называется +"владение" объектом), то объект будет доступен к использованию (еще известно +как "право владения"). + +Когда экземпляр владеет объектом, его ссылка увеличивается на один. Когда +объекта освобождается, счетчик ссылки уменьшается на один. Когда счетчик ссылки +равен нулю, объект удаляется из памяти. + +Над всеми объектами взаимодействуют, следуя паттерну: +(1) создание объекта, (2) использование объекта, (3) затем освобождение объекта из памяти. +*/ + +MyClass *classVar = [MyClass alloc]; // 'alloc' устанавливает счетчик ссылки +// объекта classVar на 1 и возвращает указатель на объект. +[classVar release]; // Уменьшает счетчик ссылки объекта classVar +// 'retain' заявляет право собственности на существующий экземпляр объекта +// и увеличивает счетчик ссылки. Затем вернет указатель на объект. +MyClass *newVar = [classVar retain]; // Если classVar освободится, объект +// останется в памяти, потому что newVar - владелец +[classVar autorelease]; // Удалит право на владение объектом +// в конце @autoreleasepool блока. Вернет указатель на объект. + +// @property может использовать 'retain' и 'assign' тоже для маленького +// удобного определения +@property (retain) MyClass *instance; // Освободит старое значение и сохранит +// одно новое (строгая ссылка) +@property (assign) NSSet *set; // Укажет на новое значение +// без сохранения/освобождения старого значения (слабая ссылка) + +// Автоматический подсчет ссылок (ARC) +// Управление памятью может быть трудным, поэтому в Xcode 4.2 и iOS 4 введен +// автоматический подсчет ссылок (ARC). +// ARC - это особенность компилятора, который помещает "retain", "release" +// и "autorelease" автоматически за вас тогда, когда используется ARC, +// вам не нужно больше обращаться к "retain", "relase" или "autorelease" +MyClass *arcMyClass = [[MyClass alloc] init]; +// ... код, использующий объект arcMyClass +// Без ARC, вам нужно было бы вызвать: [arcMyClass release] после того, как вы +// завершите работу с объектом arcMyClass. Но с ARC, +// теперь этого не нужно делать. Он будет помещать release-вызов за вас + +// Что касается 'assign' и 'retain' @property атрибутов, в ARC вы должны +// использовать 'weak' и 'strong' +@property (weak) MyClass *weakVar; // 'weak' не принимает право на владение +// объектом. Если исходный счетчик ссылки экземпляра обнуляется, +// weakVar-свойство автоматически примет значение nil, +// во избежание падения приложения +@property (strong) MyClass *strongVar; // 'strong' принимает право на владение +// объектом. Гарантирует, что объект останится в памяти для использования + +// Для обычных переменных (не объявленных с помощью @property), используйте +// следующий способ: +__strong NSString *strongString; // По умолчанию. Переменная сохраняется в памяти, +// пока она не покинет область видимости +__weak NSSet *weakSet; // Слабая ссылка на существующий объект. Когда существующий +// объект освобождается, weakSet принимает nil +__unsafe_unretained NSArray *unsafeArray; // Похож на __weak, но unsafeArray +// не принимает nil, когда существующий объект освобождается + +``` +## На почитать + +[Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C) + +[Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/) + +[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started) + +[iOS разработчик: Обзор книг для новичка](http://habrahabr.ru/post/166213/) + +[Хочешь быть iOS разработчиком? Будь им!](http://www.pvsm.ru/ios/12662/print/) diff --git a/ru-ru/paren-ru.html.markdown b/ru-ru/paren-ru.html.markdown new file mode 100644 index 00000000..9b801e46 --- /dev/null +++ b/ru-ru/paren-ru.html.markdown @@ -0,0 +1,196 @@ +--- +language: Paren +filename: learnparen-ru.paren +contributors: + - ["KIM Taegyoon", "https://github.com/kimtg"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +[Paren](https://bitbucket.org/ktg/paren) - это диалект языка Лисп. Он спроектирован как встроенный язык. + +Примеры взяты <http://learnxinyminutes.com/docs/racket/>. + +```scheme +;;; Комментарии +# комментарии + +;; Однострочные комментарии начинаются с точки с запятой или символа решетки + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Примитивные типы данных и операторы +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Числа +123 ; int +3.14 ; double +6.02e+23 ; double +(int 3.14) ; => 3 : int +(double 123) ; => 123 : double + +;; Обращение к функции записывается так: (f x y z ...), +;; где f - функция, а x, y, z, ... - операнды +;; Если вы хотите создать буквальный список данных, используйте (quote), чтобы +;; предотвратить ненужные вычисления +(quote (+ 1 2)) ; => (+ 1 2) +;; Итак, некоторые арифметические операции +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(^ 2 3) ; => 8 +(/ 5 2) ; => 2 +(% 5 2) ; => 1 +(/ 5.0 2) ; => 2.5 + +;;; Логический тип +true ; обозначает истину +false ; обозначает ложь +(! true) ; => false +(&& true false (prn "досюда не доходим")) ; => false +(|| false true (prn "досюда не доходим")) ; => true + +;;; Символы - это числа (int). +(char-at "A" 0) ; => 65 +(chr 65) ; => "A" + +;;; Строки - это массив символов с фиксированной длиной. +"Привет, мир!" +"Benjamin \"Bugsy\" Siegel" ; обратная косая черта экранирует символ +"Foo\tbar\r\n" ; включает управляющие символы в стиле Cи: \t \r \n + +;; Строки тоже могут объединяться! +(strcat "Привет " "мир!") ; => "Привет мир!" + +;; Строка может трактоваться подобно списку символов +(char-at "Apple" 0) ; => 65 + +;; Выводить информацию достаточно легко +(pr "Я" "Paren. ") (prn "Приятно познакомиться!") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Переменные +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Вы можете создать или инициализировать переменную, используя (set) +;; имя переменной может содержать любой символ, исключая: ();#" +(set some-var 5) ; => 5 +some-var ; => 5 + +;; Обращение к переменной, прежде не определенной, вызовет исключение +; x ; => Неизвестная переменная: x : nil + +;; Локальное связывание: Используйте лямбда-вычисление! `a' и `b' связывается +;; с `1' и `2' только в пределах (fn ...) +((fn (a b) (+ a b)) 1 2) ; => 3 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Коллекции +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Списки + +;; Списки подобны динамическому массиву (vector). (произвольный доступ равен O(1).) +(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3) +;; `list' - это удобный конструктор списков с переменным числом элементов +(list 1 2 3) ; => (1 2 3) +;; и quote может также использоваться для литеральных значений списка +(quote (+ 1 2)) ; => (+ 1 2) + +;; Можно еще использовать `cons', чтобы добавить элемент в начало списка +(cons 0 (list 1 2 3)) ; => (0 1 2 3) + +;; Списки являются основным типом, поэтому для них предусмотрено *много* функций +;; немного примеров из них: +(map inc (list 1 2 3)) ; => (2 3 4) +(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4) +(length (list 1 2 3 4)) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Функции +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Используйте `fn' для создания функций. +;; Функция всегда возвращает значение своего последнего выражения +(fn () "Привет Мир") ; => (fn () Привет Мир) : fn + +;; Используйте скобки, чтобы вызвать все функции, в том числе лямбда-выражение +((fn () "Привет Мир")) ; => "Привет Мир" + +;; Назначить функцию переменной +(set hello-world (fn () "Привет Мир")) +(hello-world) ; => "Привет Мир" + +;; Вы можете сократить это, используя синтаксический сахар определения функции: +(defn hello-world2 () "Привет Мир") + +;; Как и выше, () - это список аргументов для функции +(set hello + (fn (name) + (strcat "Привет " name))) +(hello "Стив") ; => "Привет Стив" + +;; ... или, что эквивалентно, используйте синтаксический сахар определения: +(defn hello2 (name) + (strcat "Привет " name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Равенство +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; для чисел используйте `==' +(== 3 3.0) ; => true +(== 2 1) ; => false + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Поток управления +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Условный оператор + +(if true ; проверка выражения + "это - истина" ; тогда это выражение + "это - ложь") ; иначе другое выражение +; => "это - истина" + +;;; Циклы + +;; Цикл for для чисел +;; (for ИДЕНТИФИКАТОР НАЧАЛО КОНЕЦ ШАГ ВЫРАЖЕНИЕ ..) +(for i 0 10 2 (pr i "")) ; => печатает 0 2 4 6 8 10 +(for i 0.0 10 2.5 (pr i "")) ; => печатает 0 2.5 5 7.5 10 + +;; Цикл while +((fn (i) + (while (< i 10) + (pr i) + (++ i))) 0) ; => печатает 0123456789 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Изменение +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Используйте `set', чтобы назначить новое значение переменной или памяти +(set n 5) ; => 5 +(set n (inc n)) ; => 6 +n ; => 6 +(set a (list 1 2)) ; => (1 2) +(set (nth 0 a) 3) ; => 3 +a ; => (3 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Макросы +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Макросы позволяют вам расширять синтаксис языка. +;; Paren-макросы легкие. +;; Фактически, (defn) - это макрос. +(defmacro setfn (name ...) (set name (fn ...))) +(defmacro defn (name ...) (def name (fn ...))) + +;; Давайте добавим инфиксную нотацию +(defmacro infix (a op ...) (op a ...)) +(infix 1 + 2 (infix 3 * 4)) ; => 15 + +;; Макросы приводят к неясному коду, т.е. вы можете затереть существующие переменные! +;; Они являются кодопреобразующей конструкцией. +``` diff --git a/ru-ru/php-ru.html.markdown b/ru-ru/php-ru.html.markdown new file mode 100644 index 00000000..53b2f916 --- /dev/null +++ b/ru-ru/php-ru.html.markdown @@ -0,0 +1,663 @@ +--- +language: PHP +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +translators: + - ["SlaF", "https://github.com/SlaF"] +lang: ru-ru +filename: learnphp-ru.php +--- + +Этот документ описывает версию PHP 5 и выше. + +```php +<?php // PHP код должен быть заключен в теги <?php + +// Если ваш файл содержит только PHP код, то можно +// пропустить закрывающийся ?> + +// А так начинаются комментарии + +# Это тоже комментарий но // предпочтительнее + +/* + Окруженный /* и */ текст превращается + в многострочный комментарий +*/ + +// Используйте "echo" или "print" для вывода. +print('Hello '); // Напечатать "Hello " без перевода строки + +// () необязательно применять для print и echo +echo "World\n"; // Печатать "World" и перейти на новую строку. +// (все утверждения должны заканчиваться ;) + +// Любые символы за пределами закрывающегося тега выводятся автоматически: +?> +Hello World Again! +<?php + + +/************************************ + * Типы и Переменные + */ + +// Переменные начинаются с символа $. +// Правильное имя переменной начинается с буквы или знака подчеркивания, +// и может содержать любые цифры, буквы, или знаки подчеркивания. +// Не рекомендуется использовать кирилические символы в именах (прим. пер.) + +// Логические значения нечувствительны к регистру +$boolean = true; // или TRUE или True +$boolean = false; // или FALSE или False + +// Целые числа +$int1 = 12; // => 12 +$int2 = -12; // => -12- +$int3 = 012; // => 10 (ведущий 0 обозначает восьмеричное число) +$int4 = 0x0F; // => 15 (ведущие символы 0x означает шестнадцатеричное число) + +// Дробные числа +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Арифметика +$sum = 1 + 1; // 2 +$difference = 2 - 1; // 1 +$product = 2 * 2; // 4 +$quotient = 2 / 1; // 2 + +// Арифметические сокращения +$number = 0; +$number += 1; // Увеличивает $number на 1 +echo $number++; // Печатает 1 (инкрементируется после вывода) +echo ++$number; // Печатает 3 (инкрементируется до вывода) +$number /= $float; // Делится и результат присваивается $number + +// Строки должны быть заключены в одинарные кавычки; +$sgl_quotes = '$String'; // => '$String' + +// Избегайте двойных кавычек за исключением случаев интерполирования переменной +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' + +// Специальные (escape) символы работают только в двойных кавычках +$escaped = "This contains a \t tab character."; +$unescaped = 'This just contains a slash and a t: \t'; + +// Заключайте переменные в фигурные скобки если это необходимо +$money = "I have $${number} in the bank."; + +// Начиная с PHP 5.3, синтаксис nowdocs может использоваться для +// неинтерполированного многострочного текста +$nowdoc = <<<'END' +Multi line +string +END; + +// Heredocs поддерживает интерполяцию переменных +$heredoc = <<<END +Multi line +$sgl_quotes +END; + +// Строки соединяются при помощи . +echo 'This string ' . 'is concatenated'; + + +/******************************** + * Константы + */ + +// Константа определяется при помощи define() +// и никогда не может быть изменена во время выполнения программы! + +// Правильное имя константы начинается с буквы или символа подчеркивания, +// и содержит любое колличество букв, цифр и знаков подчеркивания. +define("FOO", "something"); + +// Доступ к константе возможен через прямое указание её имени +echo 'This outputs '.FOO; + +/******************************** + * Массивы + */ + +// Все массивы в PHP - это ассоциативные массивы или хеши, + +// Ассоциативные массивы, известные в других языках как хеш-карты. + +// Работает во всех версиях РHP +$associative = array('One' => 1, 'Two' => 2, 'Three' => 3); + +// В PHP 5.4 появился новый синтаксис +$associative = ['One' => 1, 'Two' => 2, 'Three' => 3]; + +echo $associative['One']; // печатает 1 + +// Список тоже содержит целочисленные ключи +$array = ['One', 'Two', 'Three']; +echo $array[0]; // => "One" + + +/******************************** + * Вывод + */ + +echo('Hello World!'); +// Печатает Hello World! на stdout. +// Stdout это веб-страница запущенная в браузере. + +print('Hello World!'); // Аналогично echo + +// echo - это конструкция языка, вы можете опустить скобки. +echo 'Hello World!'; +print 'Hello World!'; // Выводит Hello World! + +$paragraph = 'paragraph'; + +echo 100; // Печать скалярной переменной напрямую +echo $paragraph; // или печать переменной + +// Если короткие теги разрешены, или ваша версия PHP >= 5.4 +// вы можете использовать сокращенный синтаксис echo +?> +<p><?= $paragraph ?></p> +<?php + +$x = 1; +$y = 2; +$x = $y; // $x теперь содержит значение переменной $y +$z = &$y; +// $z содержит ссылку на $y. Изменение значения $z затронет значение $y и наоборот. +// Значение $x остается неизменным. + +echo $x; // => 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 + + +/******************************** + * Логические выражения + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; + +// Утверждение (assert) выдает предупреждение если аргумент не true + +// Эти сравнения всегда будут истинными, даже если типы будут различаться +assert($a == $b); // "равно" +assert($c != $a); // "не равно" +assert($c <> $a); // другое обозначение "не равно" +assert($a < $c); // меньше +assert($c > $b); // больше +assert($a <= $b); // меньше или равно +assert($c >= $d); // больше или равно + +// Следующие утверждения истинны если переменные имеют одинаковый тип. +assert($c === $d); +assert($a !== $d); +assert(1 == '1'); +assert(1 !== '1'); + +// Переменные могут изменять тип, в зависимости от их использования. +$integer = 1; +echo $integer + $integer; // => 2 + +$string = '1'; +echo $string + $string; // => 2 (строка превращается в число) + +// Выводится 0 по той причине, что оператор + не может привести строку 'one' к +// числовому типу +$string = 'one'; +echo $string + $string; // => 0 + +// Приведение типов (type casting) может быть использовано для преобразование +// переменной в другой тип +$boolean = (boolean) 1; // => true + +$zero = 0; +$boolean = (boolean) $zero; // => false + +// Также существуют функции выполняющие приведение типов +$integer = 5; +$string = strval($integer); +$float = floatval($integer); + +$var = null; // Null + +// И похожая по действию функция +$integer = 10; +$boolen = settype($integer, "string") // теперь $integer имеет строковый тип + +// settype возвращает true - если преобразование удалось и false в противном случае + +/******************************** + * Управляющие структуры + */ + +if (true) { + print 'I get printed'; +} + +if (false) { + print 'I don\'t'; +} else { + print 'I get printed'; +} + +if (false) { + print 'Does not get printed'; +} elseif(true) { + print 'Does'; +} + +// Тернарный оператор +print (false ? 'Does not get printed' : 'Does'); + +$x = 0; +if ($x === '0') { + print 'Does not print'; +} elseif($x == '1') { + print 'Does not print'; +} else { + print 'Does print'; +} + +// Альтернативный синтаксис полезный для шаблонов +?> + +<?php if ($x): ?> +This is displayed if the test is truthy. +<?php else: ?> +This is displayed otherwise. +<?php endif; ?> + +<?php + +// Использование switch. +switch ($x) { + case '0': + print 'Switch does type coercion'; + break; // You must include a break, or you will fall through + // to cases 'two' and 'three' + case 'two': + case 'three': + // Do something if $variable is either 'two' or 'three' + break; + default: + // Do something by default +} + +// Циклы: while, do...while и for +$i = 0; +while ($i < 5) { + echo $i++; +}; // Prints "01234" + +echo "\n"; + +$i = 0; +do { + echo $i++; +} while ($i < 5); // Prints "01234" + +echo "\n"; + +for ($x = 0; $x < 10; $x++) { + echo $x; +} // Prints "0123456789" + +echo "\n"; + +$wheels = ['bicycle' => 2, 'car' => 4]; + +// Циклы foreach могут обходить массивы +foreach ($wheels as $wheel_count) { + echo $wheel_count; +} // Prints "24" + +echo "\n"; + +// Вы можете обходить как ключи, так и их значения +foreach ($wheels as $vehicle => $wheel_count) { + echo "A $vehicle has $wheel_count wheels"; +} + +echo "\n"; + +$i = 0; +while ($i < 5) { + if ($i === 3) { + break; // Exit out of the while loop + } + echo $i++; +} // Prints "012" + +for ($i = 0; $i < 5; $i++) { + if ($i === 3) { + continue; // Skip this iteration of the loop + } + echo $i; +} // Prints "0124" + + +/******************************** + * Функции + */ + +// Определение функции: +function my_function () { + return 'Hello'; +} + +echo my_function(); // => "Hello" + +// Правильное имя функции начинается с буквы или символа подчеркивания +// и состоит из букв, цифр или знаков подчеркивания. + +function add ($x, $y = 1) { // $y по умолчанию равно 1 + $result = $x + $y; + return $result; +} + +echo add(4); // => 5 +echo add(4, 2); // => 6 + +// $result недоступна за пределами функции +// print $result; // Выдает предупреждение + +// Начиная с PHP 5.3 вы можете объявлять анонимные функции: +$inc = function ($x) { + return $x + 1; +}; + +echo $inc(2); // => 3 + +function foo ($x, $y, $z) { + echo "$x - $y - $z"; +} + +// Функции могут возвращать функции +function bar ($x, $y) { + // Используйте 'use' для передачи внешних переменных + return function ($z) use ($x, $y) { + foo($x, $y, $z); + }; +} + +$bar = bar('A', 'B'); +$bar('C'); // Prints "A - B - C" + +// Вы можете вызывать именованные функции используя строки +$function_name = 'add'; +echo $function_name(1, 2); // => 3 +// Полезно для программного определения запущенной функции. +// Или используйте call_user_func(callable $callback [, $parameter [, ... ]]); + + +/******************************** + * Includes + */ + +<?php +// PHP код внутри включаемого файла должен начинаться с тега PHP. + +include 'my-file.php'; +// Код в файле my-file.php теперь доступен в текущем в текущем пространстве имен. +// Если файл не удалось включить, будет выдано предупреждение. + +include_once 'my-file.php'; +// Если код в файле my-file.php уже был включен, он не будет включен повторно. +// Это предотвращает ошибку повторного включения файла. + +require 'my-file.php'; +require_once 'my-file.php'; + +// Same as include(), except require() will cause a fatal error if the +// file cannot be included. +// Действует также как и include(), но если файл не удалось подключить, +// функция выдает неисправимую ошибку + +// Содержимое файла my-include.php: +<?php + +return 'Anything you like.'; +// Конец файла + +// Эти функции могут также возвращать значения. +$value = include 'my-include.php'; + +// Имена файлов содержат их путь в файловой системе, или если передано просто +// имя файла, PHP обращается к директиве include_path. Если файл не найден в +// include_path, предпринимается попытка поиска в папке, где выполняется скрипт +// или в текущей рабочей директории. Если не в одном из этих мест файл не +// найден - выдается ошибка +/* */ + +/******************************** + * Классы + */ + +// Классы определяются при помощи ключевого слова "class" + +class MyClass +{ + const MY_CONST = 'value'; // A constant + + static $staticVar = 'static'; + + // Properties must declare their visibility + public $property = 'public'; + public $instanceProp; + protected $prot = 'protected'; // Accessible from the class and subclasses + private $priv = 'private'; // Accessible within the class only + + // Create a constructor with __construct + public function __construct($instanceProp) { + // Access instance variables with $this + $this->instanceProp = $instanceProp; + } + + // Methods are declared as functions inside a class + public function myMethod() + { + print 'MyClass'; + } + + final function youCannotOverrideMe() + { + } + + public static function myStaticMethod() + { + print 'I am static'; + } +} + +echo MyClass::MY_CONST; // Выведет 'value'; +echo MyClass::$staticVar; // Выведет 'static'; +MyClass::myStaticMethod(); // Выведет 'I am static'; + +// Новый экземпляр класса используя new +$my_class = new MyClass('An instance property'); + +// Если аргументы отсутствуют, можно не ставить круглые скобки + +// Доступ к членам класса используя -> +echo $my_class->property; // => "public" +echo $my_class->instanceProp; // => "An instance property" +$my_class->myMethod(); // => "MyClass" + +// Наследование классов используя "extends" +class MyOtherClass extends MyClass +{ + function printProtectedProperty() + { + echo $this->prot; + } + + // Override a method + function myMethod() + { + parent::myMethod(); + print ' > MyOtherClass'; + } +} + +$my_other_class = new MyOtherClass('Instance prop'); +$my_other_class->printProtectedProperty(); // => Выведет "protected" +$my_other_class->myMethod(); // Выведет "MyClass > MyOtherClass" + +final class YouCannotExtendMe +{ +} + +// Вы можете использовать "магические методы" для создания геттеров и сеттеров +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; // Будет использован метод __get() +$x->property = 'Something'; // Будет использован метод __set() + +// Классы могут быть абстрактными (используя ключевое слово abstract) +// или реализовывать интерфейсы (используя ключевое слово implements). +// Интерфейсы определяются при помощи ключевого слова interface + +interface InterfaceOne +{ + public function doSomething(); +} + +interface InterfaceTwo +{ + public function doSomethingElse(); +} + +// Интерфейсы могут быть расширены +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'; + } +} + +// Классы могут реализовывать более одного интерфейса +class SomeOtherClass implements InterfaceOne, InterfaceTwo +{ + public function doSomething() + { + echo 'doSomething'; + } + + public function doSomethingElse() + { + echo 'doSomethingElse'; + } +} + + +/******************************** + * Трейты + */ + +// Трейты появились в PHP 5.4.0 и объявляются при помощи ключевого слова trait + +trait MyTrait +{ + public function myTraitMethod() + { + print 'I have MyTrait'; + } +} + +class MyTraitfulClass +{ + use MyTrait; +} + +$cls = new MyTraitfulClass(); +$cls->myTraitMethod(); // Prints "I have MyTrait" + + +/******************************** + * Пространства имен + */ + +// Это секция особая, ведь объявление пространства имен +// должно быть самым первым в файле. Позвольте сделать вид, что это не так + +<?php + +// По умолчанию, классы существуют в глобальном пространстве имен и могут быть +// вызваны с обратным слешем. + +$cls = new \MyClass(); + +// Задание пространства имен файла +namespace My\Namespace; + +class MyClass +{ +} + +// (из другого файла) +$cls = new My\Namespace\MyClass; + +// Или внутри другого пространства имен. +namespace My\Other\Namespace; + +use My\Namespace\MyClass; + +$cls = new MyClass(); + +// Или вы можете создать псевдоним для пространства имен: +namespace My\Other\Namespace; + +use My\Namespace as SomeOtherNamespace; + +$cls = new SomeOtherNamespace\MyClass(); + +*/ + +``` + +## Смотрите также: +Посетите страницу [официальной документации PHP](http://www.php.net/manual/) для справки. +Если вас интересуют полезные приемы использования PHP посетите [PHP The Right Way](http://www.phptherightway.com/). +Если вы раньше пользовались языком с хорошей организацией пакетов, посмотрите [Composer](http://getcomposer.org/). +Для изучения стандартов использования языка посетите PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards). diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown new file mode 100644 index 00000000..a0e2b474 --- /dev/null +++ b/ru-ru/python-ru.html.markdown @@ -0,0 +1,640 @@ +--- +language: python +lang: ru-ru +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Yury Timofeev", "http://twitter.com/gagar1n"] + - ["Andre Polykanine", "https://github.com/Oire"] +filename: learnpython-ru.py +--- + +Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из +самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис — это +почти исполняемый псевдокод. + +С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh) +или louiedinh [at] [почтовый сервис Google] + +Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x. +Чтобы изучить Python 3.x, обратитесь к статье по Python 3. + +```python +# Однострочные комментарии начинаются с символа решётки. +""" Многострочный текст может быть + записан, используя 3 знака " и обычно используется + в качестве встроенной документации +""" + +#################################################### +## 1. Примитивные типы данных и операторы +#################################################### + +# У вас есть числа +3 #=> 3 + +# Математика работает вполне ожидаемо +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# А вот деление немного сложнее. В этом случае происходит деление +# целых чисел, и результат автоматически округляется в меньшую сторону. +5 / 2 #=> 2 + +# Чтобы делить правильно, сначала нужно немного узнать о числах +# с плавающей запятой. +2.0 # Это число с плавающей запятой +11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше + +# Результат целочисленного деления округляется в меньшую сторону +# как для положительных, так и для отрицательных чисел. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Остаток от деления +7 % 3 # => 1 + +# Возведение в степень +2**4 # => 16 + +# Приоритет операций указывается скобками +(1 + 3) * 2 #=> 8 + +# Логические операторы +# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв +True and False #=> False +False or True #=> True + +# Обратите внимание, что логические операторы используются и с целыми числами +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Для отрицания используется ключевое слово not +not True #=> False +not False #=> True + +# Равенство — это == +1 == 1 #=> True +2 == 1 #=> False + +# Неравенство — это != +1 != 1 #=> False +2 != 1 #=> True + +# Ещё немного сравнений +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Сравнения могут быть записаны цепочкой! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Строки определяются символом " или ' +"Это строка." +'Это тоже строка.' + +# И строки тоже можно складывать! +"Привет " + "мир!" #=> "Привет мир!" + +# ... или умножать +"Привет" * 3 # => "ПриветПриветПривет" + +# Со строкой можно работать, как со списком символов +"Это строка"[0] #=> 'Э' + +# Символ % используется для форматирования строк, например: +"%s могут быть %s" % ("строки", "интерполированы") + +# Новый способ форматирования строк — использование метода format. +# Это предпочитаемый способ. +"{0} могут быть {1}".format("строки", "форматированы") + +# Если вы не хотите считать, можете использовать ключевые слова. +"{name} хочет есть {food}".format(name="Боб", food="лазанью") + +# None является объектом +None #=> None + +# Не используйте оператор равенства '=='' для сравнения +# объектов с None. Используйте для этого «is» +"etc" is None #=> False +None is None #=> True + +# Оператор 'is' проверяет идентичность объектов. Он не +# очень полезен при работе с примитивными типами, но +# зато просто незаменим при работе с объектами. + +# None, 0 и пустые строки/списки равны False. +# Все остальные значения равны True +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Переменные и коллекции +#################################################### + +# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3 +print "Я Python. Приятно познакомиться!" +# В Python также есть функция print(), доступная в версиях 2.7 и 3, +# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)): +# from __future__ import print_function +print("Я тоже Python! ") + +# Объявлять переменные перед инициализацией не нужно. +some_var = 5 # По соглашению используется нижний_регистр_с_подчёркиваниями +some_var #=> 5 + +# При попытке доступа к неинициализированной переменной +# выбрасывается исключение. +# См. раздел «Поток управления» для информации об исключениях. +some_other_var # Выбрасывает ошибку именования + +# if может быть использован как выражение +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Списки хранят последовательности +li = [] +# Можно сразу начать с заполненного списка +other_li = [4, 5, 6] + +# Объекты добавляются в конец списка методом append +li.append(1) # [1] +li.append(2) # [1, 2] +li.append(4) # [1, 2, 4] +li.append(3) # [1, 2, 4, 3] +# И удаляются с конца методом pop +li.pop() #=> возвращает 3 и li становится равен [1, 2, 4] +# Положим элемент обратно +li.append(3) # [1, 2, 4, 3]. + +# Обращайтесь со списком, как с обычным массивом +li[0] #=> 1 +# Присваивайте новые значения уже инициализированным индексам с помощью = +li[0] = 42 +li[0] # => 42 +li[0] = 1 # Обратите внимание: возвращаемся на исходное значение +# Обратимся к последнему элементу +li[-1] #=> 3 + +# Попытка выйти за границы массива приведёт к ошибке индекса +li[4] # Выдаёт IndexError + +# Можно обращаться к диапазону, используя так называемые срезы +# (Для тех, кто любит математику, это называется замкнуто-открытый интервал). +li[1:3] #=> [2, 4] +# Опускаем начало +li[2:] #=> [4, 3] +# Опускаем конец +li[:3] #=> [1, 2, 4] +# Выбираем каждый второй элемент +li[::2] # =>[1, 4] +# Переворачиваем список +li[::-1] # => [3, 4, 2, 1] +# Используйте сочетания всего вышеназванного для выделения более сложных срезов +# li[начало:конец:шаг] + +# Удаляем произвольные элементы из списка оператором del +del li[2] # li теперь [1, 2, 3] + +# Вы можете складывать, или, как ещё говорят, конкатенировать списки +li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются +# Обратите внимание: значения li и other_li при этом не изменились. + +# Объединять списки можно методом extend +li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6] + +# Проверить элемент на вхождение в список можно оператором in +1 in li #=> True + +# Длина списка вычисляется функцией len +len(li) #=> 6 + + +# Кортежи — это такие списки, только неизменяемые +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Выдаёт TypeError + +# Всё то же самое можно делать и с кортежами +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Вы можете распаковывать кортежи (или списки) в переменные +a, b, c = (1, 2, 3) # a == 1, b == 2 и c == 3 +# Кортежи создаются по умолчанию, если опущены скобки +d, e, f = 4, 5, 6 +# Обратите внимание, как легко поменять местами значения двух переменных +e, d = d, e # теперь d == 5, а e == 4 + + +# Словари содержат ассоциативные массивы +empty_dict = {} +# Вот так описывается предзаполненный словарь +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Значения извлекаются так же, как из списка, с той лишь разницей, +# что индекс — у словарей он называется ключом — не обязан быть числом +filled_dict["one"] #=> 1 + +# Можно получить все ключи в виде списка с помощью метода keys +filled_dict.keys() #=> ["three", "two", "one"] +# Замечание: сохранение порядка ключей в словаре не гарантируется +# Ваши результаты могут не совпадать с этими. + +# Можно получить и все значения в виде списка, используйте метод values +filled_dict.values() #=> [3, 2, 1] +# То же самое замечание насчёт порядка ключей справедливо и здесь + +# При помощи оператора in можно проверять ключи на вхождение в словарь +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Попытка получить значение по несуществующему ключу выбросит ошибку ключа +filled_dict["four"] # KeyError + +# Чтобы избежать этого, используйте метод get() +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# Метод get также принимает аргумент по умолчанию, значение которого будет +# возвращено при отсутствии указанного ключа +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 +# Обратите внимание, что filled_dict.get("four") всё ещё => None +# (get не устанавливает значение элемента словаря) + +# Присваивайте значение ключам так же, как и в списках +filled_dict["four"] = 4 # теперь filled_dict["four"] => 4 + +# Метод setdefault вставляет() пару ключ-значение, только если такого ключа нет +filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5 +filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5 + + +# Множества содержат... ну, в общем, множества +# (которые похожи на списки, только в них не может быть дублирующихся элементов) +empty_set = set() +# Инициализация множества набором значений +some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4]) + +# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными +another_set = set([4, 3, 2, 2, 1]) # another_set теперь set([1, 2, 3, 4]) + +# Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество +filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4} + +# Добавление новых элементов в множество +filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5} + +# Пересечение множеств: & +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Объединение множеств: | +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Разность множеств: - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Проверка на вхождение во множество: in +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Поток управления +#################################################### + +# Для начала заведём переменную +some_var = 5 + +# Так выглядит выражение if. Отступы в python очень важны! +# результат: «some_var меньше, чем 10» +if some_var > 10: + print("some_var намного больше, чем 10.") +elif some_var < 10: # Выражение elif необязательно. + print("some_var меньше, чем 10.") +else: # Это тоже необязательно. + print("some_var равно 10.") + + +""" +Циклы For проходят по спискам + +Результат: + собака — это млекопитающее + кошка — это млекопитающее + мышь — это млекопитающее +""" +for animal in ["собака", "кошка", "мышь"]: + # Можете использовать оператор % для интерполяции форматированных строк + print("%s — это млекопитающее" % animal) + +""" +«range(число)» возвращает список чисел +от нуля до заданного числа +Результат: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +Циклы while продолжаются до тех пор, пока указанное условие не станет ложным. +Результат: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Краткая запись для x = x + 1 + +# Обрабатывайте исключения блоками try/except + +# Работает в Python 2.6 и выше: +try: + # Чтобы выбросить ошибку, используется raise + raise IndexError("Это ошибка индекса") +except IndexError as e: + # pass — это просто отсутствие оператора. Обычно здесь происходит + # восстановление после ошибки. + pass +except (TypeError, NameError): + pass # Несколько исключений можно обработать вместе, если нужно. +else: # Необязательное выражение. Должно следовать за последним блоком except + print("Всё хорошо!") # Выполнится, только если не было никаких исключений + + + +#################################################### +## 4. Функции +#################################################### + +# Используйте def для создания новых функций +def add(x, y): + print("x равен %s, а y равен %s" % (x, y)) + return x + y # Возвращайте результат с помощью ключевого слова return + +# Вызов функции с аргументами +add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11 + +# Другой способ вызова функции — вызов с именованными аргументами +add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке. + +# Вы можете определить функцию, принимающую переменное число аргументов, +# которые будут интерпретированы как кортеж, если вы не используете * +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# А также можете определить функцию, принимающую переменное число +# именованных аргументов, которые будут интерпретированы как словарь, +# если вы не используете ** +def keyword_args(**kwargs): + return kwargs + +# Вызовем эту функцию и посмотрим, что из этого получится +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Если хотите, можете использовать оба способа одновременно +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) выводит: + (1, 2) + {"a": 3, "b": 4} +""" + +# Вызывая функции, можете сделать наоборот! +# Используйте символ * для распаковки кортежей и ** для распаковки словарей +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # эквивалентно foo(1, 2, 3, 4) +all_the_args(**kwargs) # эквивалентно foo(a=3, b=4) +all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4) + +# вы можете передавать переменное число позиционных или именованных аргументов +# другим функциям, которые их принимают, распаковывая их с помощью +# * или ** соответственно +def pass_all_the_args(*args, **kwargs): + all_the_args(*args, **kwargs) + print varargs(*args) + print keyword_args(**kwargs) + +# Область определения функций +x = 5 + +def setX(num): + # Локальная переменная x — это не то же самое, что глобальная переменная x + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # Глобальная переменная x теперь равна 6 + print (x) # => 6 + +setX(43) +setGlobalX(6) + +# В Python функции — «объекты первого класса» +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Также есть и анонимные функции +(lambda x: x > 2)(3) #=> True + +# Есть встроенные функции высшего порядка +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Для удобного отображения и фильтрации можно использовать списочные включения +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Классы +#################################################### + +# Чтобы получить класс, мы наследуемся от object. +class Human(object): + + # Атрибут класса. Он разделяется всеми экземплярами этого класса + species = "H. sapiens" + + # Обычный конструктор, вызывается при инициализации экземпляра класса + # Обратите внимание, что двойное подчёркивание в начале и в конце имени + # означает объекты и атрибуты, которые используются Python, но находятся + # в пространствах имён, управляемых пользователем. + # Не придумывайте им имена самостоятельно. + def __init__(self, name): + # Присваивание значения аргумента атрибуту класса name + self.name = name + + # Метод экземпляра. Все методы принимают self в качестве первого аргумента + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Метод класса разделяется между всеми экземплярами + # Они вызываются с указыванием вызывающего класса в качестве первого аргумента + @classmethod + def get_species(cls): + return cls.species + + # Статический метод вызывается без ссылки на класс или экземпляр + @staticmethod + def grunt(): + return "*grunt*" + + +# Инициализация экземпляра класса +i = Human(name="Иван") +print(i.say("привет")) # Выводит: «Иван: привет» + +j = Human("Пётр") +print(j.say("Привет")) # Выводит: «Пётр: привет» + +# Вызов метода класса +i.get_species() #=> "H. sapiens" + +# Изменение разделяемого атрибута +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Вызов статического метода +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Модули +#################################################### + +# Вы можете импортировать модули +import math +print(math.sqrt(16)) #=> 4 + +# Вы можете импортировать отдельные функции модуля +from math import ceil, floor +print(ceil(3.7)) #=> 4.0 +print(floor(3.7)) #=> 3.0 + +# Можете импортировать все функции модуля. +# (Хотя это и не рекомендуется) +from math import * + +# Можете сокращать имена модулей +import math as m +math.sqrt(16) == m.sqrt(16) #=> True +# Вы также можете убедиться, что функции эквивалентны +from math import sqrt +math.sqrt == m.sqrt == sqrt # => True + +# Модули в Python — это обычные Python-файлы. Вы +# можете писать свои модули и импортировать их. Название +# модуля совпадает с названием файла. + +# Вы можете узнать, какие функции и атрибуты определены +# в модуле +import math +dir(math) + +#################################################### +## 7. Дополнительно +#################################################### + +# Генераторы помогут выполнить ленивые вычисления +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Генератор создаёт значения на лету. +# Он не возвращает все значения разом, а создаёт каждое из них при каждой +# итерации. Это значит, что значения больше 15 в double_numbers +# обработаны не будут. +# Обратите внимание: xrange — это генератор, который делает то же, что и range. +# Создание списка чисел от 1 до 900000000 требует много места и времени. +# xrange создаёт объект генератора, а не список сразу, как это делает range. +# Если нам нужно имя переменной, совпадающее с ключевым словом Python, +# мы используем подчёркивание в конце +xrange_ = xrange(1, 900000000) + +# Будет удваивать все числа, пока результат не превысит 30 +for i in double_numbers(xrange_): + print(i) + if i >= 30: + break + + +# Декораторы +# В этом примере beg оборачивает say +# Метод beg вызовет say. Если say_please равно True, +# он изменит возвращаемое сообщение +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Вы не купите мне пива?" + return msg, say_please + + +print(say()) # Вы не купите мне пива? +print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :( + +``` + +## Хотите ещё? + +### Бесплатные онлайн-материалы + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Официальная документация](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +### Платные + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/ru-ru/python3-ru.html.markdown b/ru-ru/python3-ru.html.markdown new file mode 100644 index 00000000..2a7b3f7b --- /dev/null +++ b/ru-ru/python3-ru.html.markdown @@ -0,0 +1,648 @@ +--- +language: python3 +lang: ru-ru +contributors: + - ["Louie Dinh", "http://ldinh.ca"] + - ["Steven Basart", "http://github.com/xksteven"] +translators: + - ["Andre Polykanine", "https://github.com/Oire"] +filename: learnpython3-ru.py +--- + +Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из +самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис — это +почти что исполняемый псевдокод. + +С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh) +или louiedinh [at] [почтовый сервис Google] + +Замечание: Эта статья относится только к Python 3. +Если вы хотите изучить Python 2.7, обратитесь к другой статье. + +```python +# Однострочные комментарии начинаются с символа решётки. +""" Многострочный текст может быть + записан, используя 3 знака " и обычно используется + в качестве встроенной документации +""" + +#################################################### +## 1. Примитивные типы данных и операторы +#################################################### + +# У вас есть числа +3 #=> 3 + +# Математика работает вполне ожидаемо +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 + +# Кроме деления, которое по умолчанию возвращает число с плавающей запятой +35 / 5 # => 7.0 + +# Результат целочисленного деления округляется в меньшую сторону +# как для положительных, так и для отрицательных чисел. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Когда вы используете числа с плавающей запятой, +# результатом будет также число с плавающей запятой +3 * 2.0 # => 6.0 + +# Остаток от деления +7 % 3 # => 1 + +# Возведение в степень +2**4 # => 16 + +# Приоритет операций указывается скобками +(1 + 3) * 2 #=> 8 + +# Для логических (булевых) значений существует отдельный примитивный тип +True +False + +# Для отрицания используется ключевое слово not +not True #=> False +not False #=> True + +# Логические операторы +# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв +True and False #=> False +False or True #=> True + +# Обратите внимание, что логические операторы используются и с целыми числами +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Равенство — это == +1 == 1 #=> True +2 == 1 #=> False + +# Неравенство — это != +1 != 1 #=> False +2 != 1 #=> True + +# Ещё немного сравнений +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Сравнения могут быть записаны цепочкой: +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Строки определяются символом " или ' +"Это строка." +'Это тоже строка.' + +# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим. +"Привет " + "мир!" #=> "Привет мир!" + +# Со строкой можно работать, как со списком символов +"Это строка"[0] #=> 'Э' + +# Метод format используется для форматирования строк: +"{0} могут быть {1}".format("строки", "форматированы") + +# Вы можете повторять аргументы форматирования, чтобы меньше печатать. +"Ехал {0} через реку, видит {0} - в реке {1}! Сунул {0} руку в реку, {1} за руку греку цап!".format("грека", "рак") +#=> "Ехал грека через реку, видит грека - в реке рак! Сунул грека руку в реку, рак за руку греку цап!" +# Если вы не хотите считать, можете использовать ключевые слова. +"{name} хочет есть {food}".format(name="Боб", food="лазанью") + +# Если ваш код на Python 3 нужно запускать также и под Python 2.5 и ниже, +# вы также можете использовать старый способ форматирования: +"%s можно %s %s способом" % ("строки", "интерполировать", "старым") + +# None является объектом +None #=> None + +# Не используйте оператор равенства '==' для сравнения +# объектов с None. Используйте для этого 'is' +"etc" is None #=> False +None is None #=> True + +# Оператор «is» проверяет идентичность объектов. Он не +# очень полезен при работе с примитивными типами, но +# зато просто незаменим при работе с объектами. + +# None, 0 и пустые строки/списки/словари приводятся к False. +# Все остальные значения равны True +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. Переменные и коллекции +#################################################### + +# В Python есть функция Print +print("Я Python. Приятно познакомиться!") + +# Объявлять переменные перед инициализацией не нужно. +# По соглашению используется нижний_регистр_с_подчёркиваниями +some_var = 5 +some_var #=> 5 + +# При попытке доступа к неинициализированной переменной +# выбрасывается исключение. +# Об исключениях см. раздел «Поток управления и итерируемые объекты». +some_unknown_var # Выбрасывает ошибку именования + +# Списки хранят последовательности +li = [] +# Можно сразу начать с заполненного списка +other_li = [4, 5, 6] + +# Объекты добавляются в конец списка методом append +li.append(1) # [1] +li.append(2) # [1, 2] +li.append(4) # [1, 2, 4] +li.append(3) # [1, 2, 4, 3] +# И удаляются с конца методом pop +li.pop() #=> возвращает 3 и li становится равен [1, 2, 4] +# Положим элемент обратно +li.append(3) # [1, 2, 4, 3]. + +# Обращайтесь со списком, как с обычным массивом +li[0] #=> 1 +# Обратимся к последнему элементу +li[-1] #=> 3 + +# Попытка выйти за границы массива приведёт к ошибке индекса +li[4] # Выдаёт IndexError + +# Можно обращаться к диапазону, используя так называемые срезы +# (Для тех, кто любит математику, это называется замкнуто-открытый интервал). +li[1:3] #=> [2, 4] +# Опускаем начало +li[2:] #=> [4, 3] +# Опускаем конец +li[:3] #=> [1, 2, 4] +# Выбираем каждый второй элемент +li[::2] # =>[1, 4] +# Переворачиваем список +li[::-1] # => [3, 4, 2, 1] +# Используйте сочетания всего вышеназванного для выделения более сложных срезов +# li[начало:конец:шаг] + +# Удаляем произвольные элементы из списка оператором del +del li[2] # [1, 2, 3] + +# Вы можете складывать, или, как ещё говорят, конкатенировать списки +# Обратите внимание: значения li и other_li при этом не изменились. +li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются + +# Объединять списки можно методом extend +li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6] + +# Проверить элемент на вхождение в список можно оператором in +1 in li #=> True + +# Длина списка вычисляется функцией len +len(li) #=> 6 + + +# Кортежи — это такие списки, только неизменяемые +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Выдаёт TypeError + +# Всё то же самое можно делать и с кортежами +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Вы можете распаковывать кортежи (или списки) в переменные +a, b, c = (1, 2, 3) # a == 1, b == 2 и c == 3 +# Кортежи создаются по умолчанию, если опущены скобки +d, e, f = 4, 5, 6 +# Обратите внимание, как легко поменять местами значения двух переменных +e, d = d, e # теперь d == 5, а e == 4 + + +# Словари содержат ассоциативные массивы +empty_dict = {} +# Вот так описывается предзаполненный словарь +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Значения извлекаются так же, как из списка, с той лишь разницей, +# что индекс — у словарей он называется ключом — не обязан быть числом +filled_dict["one"] #=> 1 + +# Все ключи в виде списка получаются с помощью метода keys(). +# Его вызов нужно обернуть в list(), так как обратно мы получаем +# итерируемый объект, о которых поговорим позднее. +list(filled_dict.keys()) # => ["three", "two", "one"] +# Замечание: сохранение порядка ключей в словаре не гарантируется +# Ваши результаты могут не совпадать с этими. + +# Все значения в виде списка можно получить с помощью values(). +# И снова нам нужно обернуть вызов в list(), чтобы превратить +# итерируемый объект в список. +list(filled_dict.values()) # => [3, 2, 1] +# То же самое замечание насчёт порядка ключей справедливо и здесь + +# При помощи оператора in можно проверять ключи на вхождение в словарь +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Попытка получить значение по несуществующему ключу выбросит ошибку ключа +filled_dict["four"] # KeyError + +# Чтобы избежать этого, используйте метод get() +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# Метод get также принимает аргумент по умолчанию, значение которого будет +# возвращено при отсутствии указанного ключа +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет +filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5 +filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5 + +# Добавление элементов в словарь +filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} +#filled_dict["four"] = 4 # Другой способ добавления элементов + +# Удаляйте ключи из словаря с помощью оператора del +del filled_dict["one"] # Удаляет ключ «one» из словаря + + +# Множества содержат... ну, в общем, множества +empty_set = set() +# Инициализация множества набором значений. +# Да, оно выглядит примерно как словарь… ну извините, так уж вышло. +filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4} + +# Множеству можно назначать новую переменную +filled_set = some_set + +# Добавление новых элементов в множество +filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5} + +# Пересечение множеств: & +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Объединение множеств: | +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Разность множеств: - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Проверка на вхождение во множество: in +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Поток управления и итерируемые объекты +#################################################### + +# Для начала заведём переменную +some_var = 5 + +# Так выглядит выражение if. Отступы в python очень важны! +# результат: «some_var меньше, чем 10» +if some_var > 10: + print("some_var намного больше, чем 10.") +elif some_var < 10: # Выражение elif необязательно. + print("some_var меньше, чем 10.") +else: # Это тоже необязательно. + print("some_var равно 10.") + + +# Циклы For проходят по спискам. Результат: + # собака — это млекопитающее + # кошка — это млекопитающее + # мышь — это млекопитающее +for animal in ["собака", "кошка", "мышь"]: + # Можете использовать format() для интерполяции форматированных строк + print("{} — это млекопитающее".format(animal)) + +""" +«range(число)» возвращает список чисел +от нуля до заданного числа +Результат: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +Циклы while продолжаются до тех пор, пока указанное условие не станет ложным. +Результат: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Краткая запись для x = x + 1 + +# Обрабатывайте исключения блоками try/except +try: + # Чтобы выбросить ошибку, используется raise + raise IndexError("Это ошибка индекса") +except IndexError as e: + # pass — это просто отсутствие оператора. Обычно здесь происходит + # восстановление после ошибки. + pass +except (TypeError, NameError): + pass # Несколько исключений можно обработать вместе, если нужно. +else: # Необязательное выражение. Должно следовать за последним блоком except + print("Всё хорошо!") # Выполнится, только если не было никаких исключений + +# Python предоставляет фундаментальную абстракцию, +# которая называется итерируемым объектом (an iterable). +# Итерируемый объект — это объект, который воспринимается как последовательность. +# Объект, который возвратила функция range(), итерируемый. +filled_dict = {"one": 1, "two": 2, "three": 3} +our_iterable = filled_dict.keys() +print(our_iterable) #=> range(1,10). Это объект, реализующий интерфейс iterable + +# Мы можем проходить по нему циклом. +for i in our_iterable: + print(i) # Выводит one, two, three + +# Но мы не можем обращаться к элементу по индексу. +our_iterable[1] # Выбрасывает ошибку типа + +# Итерируемый объект знает, как создавать итератор. +our_iterator = iter(our_iterable) + +# Итератор может запоминать состояние при проходе по объекту. +# Мы получаем следующий объект, вызывая функцию __next__. +our_iterator.__next__() #=> "one" + +# Он сохраняет состояние при вызове __next__. +our_iterator.__next__() #=> "two" +our_iterator.__next__() #=> "three" + +# Возвратив все данные, итератор выбрасывает исключение StopIterator +our_iterator.__next__() # Выбрасывает исключение остановки итератора + +# Вы можете получить сразу все элементы итератора, вызвав на нём функцию list(). +list(filled_dict.keys()) #=> Возвращает ["one", "two", "three"] + + +#################################################### +## 4. Функции +#################################################### + +# Используйте def для создания новых функций +def add(x, y): + print("x равен %s, а y равен %s" % (x, y)) + return x + y # Возвращайте результат с помощью ключевого слова return + +# Вызов функции с аргументами +add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11 + +# Другой способ вызова функции — вызов с именованными аргументами +add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке. + +# Вы можете определить функцию, принимающую переменное число аргументов +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# А также можете определить функцию, принимающую переменное число +# именованных аргументов +def keyword_args(**kwargs): + return kwargs + +# Вызовем эту функцию и посмотрим, что из этого получится +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Если хотите, можете использовать оба способа одновременно +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) выводит: + (1, 2) + {"a": 3, "b": 4} +""" + +# Вызывая функции, можете сделать наоборот! +# Используйте символ * для распаковки кортежей и ** для распаковки словарей +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # эквивалентно foo(1, 2, 3, 4) +all_the_args(**kwargs) # эквивалентно foo(a=3, b=4) +all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4) + +# Область определения функций +x = 5 + +def setX(num): + # Локальная переменная x — это не то же самое, что глобальная переменная x + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # Глобальная переменная x теперь равна 6 + print (x) # => 6 + +setX(43) +setGlobalX(6) + +# В Python функции — «объекты первого класса» +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Также есть и анонимные функции +(lambda x: x > 2)(3) #=> True + +# Есть встроенные функции высшего порядка +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Для удобного отображения и фильтрации можно использовать списочные включения +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Классы +#################################################### + +# Чтобы получить класс, мы наследуемся от object. +class Human(object): + + # Атрибут класса. Он разделяется всеми экземплярами этого класса + species = "H. sapiens" + + # Обычный конструктор, вызывается при инициализации экземпляра класса + # Обратите внимание, что двойное подчёркивание в начале и в конце имени + # означает объекты и атрибуты, которые используются Python, но находятся + # в пространствах имён, управляемых пользователем. + # Не придумывайте им имена самостоятельно. + def __init__(self, name): + # Присваивание значения аргумента атрибуту класса name + self.name = name + + # Метод экземпляра. Все методы принимают self в качестве первого аргумента + def say(self, msg): + return "{name}: {message}".format(name=self.name, message=msg) + + # Метод класса разделяется между всеми экземплярами + # Они вызываются с указыванием вызывающего класса в качестве первого аргумента + @classmethod + def get_species(cls): + return cls.species + + # Статический метод вызывается без ссылки на класс или экземпляр + @staticmethod + def grunt(): + return "*grunt*" + + +# Инициализация экземпляра класса +i = Human(name="Иван") +print(i.say("привет")) # Выводит: «Иван: привет» + +j = Human("Пётр") +print(j.say("Привет")) # Выводит: «Пётр: привет» + +# Вызов метода класса +i.get_species() #=> "H. sapiens" + +# Изменение разделяемого атрибута +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Вызов статического метода +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Модули +#################################################### + +# Вы можете импортировать модули +import math +print(math.sqrt(16)) #=> 4 + +# Вы можете импортировать отдельные функции модуля +from math import ceil, floor +print(ceil(3.7)) #=> 4.0 +print(floor(3.7)) #=> 3.0 + +# Можете импортировать все функции модуля. +# (Хотя это и не рекомендуется) +from math import * + +# Можете сокращать имена модулей +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Модули в Python — это обычные Python-файлы. Вы +# можете писать свои модули и импортировать их. Название +# модуля совпадает с названием файла. + +# Вы можете узнать, какие функции и атрибуты определены +# в модуле +import math +dir(math) + +#################################################### +## 7. Дополнительно +#################################################### + +# Генераторы помогут выполнить ленивые вычисления +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Генератор создаёт значения на лету. +# Он не возвращает все значения разом, а создаёт каждое из них при каждой +# итерации. Это значит, что значения больше 15 в double_numbers +# обработаны не будут. +# Обратите внимание: range — это тоже генератор. +# Создание списка чисел от 1 до 900000000 требует много места и времени. +# Если нам нужно имя переменной, совпадающее с ключевым словом Python, +# мы используем подчёркивание в конце +range_ = range(1, 900000000) + +# Будет удваивать все числа, пока результат не превысит 30 +for i in double_numbers(range_): + print(i) + if i >= 30: + break + + +# Декораторы +# В этом примере beg оборачивает say +# Метод beg вызовет say. Если say_please равно True, +# он изменит возвращаемое сообщение +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Вы не купите мне пива?" + return msg, say_please + + +print(say()) # Вы не купите мне пива? +print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :( + +``` + +## Хотите ещё? + +### Бесплатные онлайн-материалы + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) +* [Официальная документация](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/3/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +### Платные + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown new file mode 100644 index 00000000..69b5fb46 --- /dev/null +++ b/ru-ru/ruby-ru.html.markdown @@ -0,0 +1,469 @@ +--- +language: ruby +lang: ru-ru +filename: learnruby-ru.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] +translators: + - ["Alexey Makarov", "https://github.com/Anakros"] +--- + +```ruby +# Это комментарий + +=begin +Это многострочный комментарий +Никто их не использует +И они не рекомендуются к использованию +=end + +# Первое и самое главное: Всё является объектом. + +# Числа это объекты + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Немного простой арифметики +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Арифметика -- это синтаксический сахар +# над вызовом метода для объекта +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Логические величины -- это объекты +nil # Здесь ничего нет +true # истина +false # ложь + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Операция равенства +1 == 1 #=> true +2 == 1 #=> false + +# Операция неравенства +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# nil -- имеет такое же логическое значение, как и false + +!nil #=> true +!false #=> true +!0 #=> false + +# Больше операций сравнения +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Строки -- это объекты + +'Я строка'.class #=> String +"Я тоже строка".class #=> String + +placeholder = "использовать интерполяцию строк" +"Я могу #{placeholder}, когда создаю строку с двойными кавычками" +#=> "Я могу использовать интерполяцию строк, +# когда создаю строку с двойными кавычками" + + +# печатать в стандартный вывод +puts "Я печатаюсь!" + +# Переменные +x = 25 #=> 25 +x #=> 25 + +# Присваивание значения возвращает то самое присвоенное значение. +# Это позволяет делать множественные присваивания: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# По соглашению, используйте snake_case для имён переменных +snake_case = true + +# Используйте подробные имена для переменных +# Но не переборщите! +path_to_project_root = '/good/name/' +path = '/bad/name/' + +# Идентификаторы (тоже объекты) + +# Идентификаторы -- это неизменяемые, многоразовые константы. +# Для каждого идентификатора (кроме текста) сохраняется цифровой хэш. +# При последующем использовании идентификатора, заместо создания нового объекта, +# будет найден уже существующий по цифровому хэшу. +# Они часто используются вместо строк для ускорения работы приложений + +:pending.class #=> Symbol + +status = :pending + +status == :pending #=> true + +status == 'pending' #=> false + +status == :approved #=> false + +# Массивы + +# Это массив +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Массив может содержать различные типы значений + +[1, "hello", false] #=> [1, "hello", false] + +# Значение в массиве можно получить по индексу с левой границы +array[0] #=> 1 +array[12] #=> nil + +# Как и арифметика, доступ к значению в массиве +# это синтаксический сахар над вызовом метода для объекта +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# Также, можно получить по индексу с правой границы +array[-1] #=> 5 + +# С заданными левой и правой границами индексов +array[2, 4] #=> [3, 4, 5] + +# Или с использованием диапазона значений +array[1..3] #=> [2, 3, 4] + +# Вот так можно добавить значение в массив +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# Хэши -- это массив пар "ключ => значение". +# Хэши объявляются с использованием фигурных скобок: +hash = {'color' => 'green', 'number' => 5} + +hash.keys #=> ['color', 'number'] +hash.values #=> ['green', 5] + +# Значение в хэше легко может быть найдено по ключу: +hash['color'] #=> 'green' +hash['number'] #=> 5 + +# Поиск по ключу, которого в хэше нет вернёт nil: +hash['nothing here'] #=> nil + +# начиная с Ruby 1.9, существует специальный синтаксис +# при использовании идентификаторов как ключей хэша: + +new_hash = { defcon: 3, action: true} + +new_hash.keys #=> [:defcon, :action] + +# Массивы и Хэши -- перечисляемые типы данных +# У них есть много полезных методов, например: each, map, count и другие + +# Управление ходом выполнения (Управляющие структуры) + +if true + "Если истина" +elsif false + "Иначе, если ложь (опционально)" +else + "Во всех других случаях" +end + +for counter in 1..5 + puts "итерация #{counter}" +end +#=> итерация 1 +#=> итерация 2 +#=> итерация 3 +#=> итерация 4 +#=> итерация 5 + +# Однако, никто не использует "for" для циклов. +# Вместо него Вы должны использовать метод "each" вместе с блоком кода. +# +# Блок кода -- это один из вариантов создания замыканий (лямбды, +# анонимные функции). +# Блок может только передаваться методу, сам по себе он существовать не может. +# "for" не имеет своей области видимости и все переменные, объявленные в нём +# будут доступны отовсюду. "each" вместе с блоком создаёт свою область видимости + +# Метод "each" для диапазона значений запускает блок кода один раз +# для каждого из значений диапазона +# Блок передаёт счётчик (counter) в качестве параметра. +# Вызов метода "each" с блоком выглядит следующим образом: + +(1..5).each do |counter| + puts "итерация #{counter}" +end +#=> итерация 1 +#=> итерация 2 +#=> итерация 3 +#=> итерация 4 +#=> итерация 5 + +# Вы также можете ограничивать блоки фигурными скобками: +(1..5).each {|counter| puts "итерация #{counter}"} + +# Содержимое структурных данных также можно перебирать используя "each": +array.each do |element| + puts "#{element} -- часть массива" +end +hash.each do |key, value| + puts "#{key} -- это #{value}" +end + +counter = 1 +while counter <= 5 do + puts "итерация #{counter}" + counter += 1 +end +#=> итерация 1 +#=> итерация 2 +#=> итерация 3 +#=> итерация 4 +#=> итерация 5 + +grade = 'B' + +case grade +when 'A' + puts "Так держать, детка!" +when 'B' + puts "Тебе повезёт в следующий раз" +when 'C' + puts "Ты можешь сделать лучше" +when 'D' + puts "Выскоблил последнее" +when 'F' + puts "Ты провалился!" +else + puts "Альтернативная система оценок, да?" +end + +# Функции + +def double(x) + x * 2 +end + +# Функции (и все блоки) неявно возвращают значение последней операции +double(2) #=> 4 + +# Скобки необязательны, если возвращаемый результат однозначен +double 3 #=> 6 + +double double 3 #=> 12 + +def sum(x,y) + x + y +end + +# Аргументы метода разделены запятой +sum 3, 4 #=> 7 + +sum sum(3,4), 5 #=> 12 + +# yield +# Все методы имеют неявный, опциональный параметр, +# который может быть вызван с помощью инструкции "yield" + +def surround + puts "{" + yield + puts "}" +end + +surround { puts 'hello world' } + +# { +# hello world +# } + + +# Определение класса с помощью ключевого слова "class" +class Human + + # Переменная класса, она является общей для всех экземпляров класса + @@species = "H. sapiens" + + # Базовый метод-конструктор + def initialize(name, age=0) + # Присвоить аргумент "name" переменной "name" экземпляра класса + @name = name + # Если аргумент "age" не задан, + # мы используем значение по умолчанию из списка аргументов + @age = age + end + + # Базовый метод установки значения для переменной (setter) + def name=(name) + @name = name + end + + # Базовый метод получения значения переменной (getter) + def name + @name + end + + # Метод класса определяется с ключевым словом "self", + # чтобы можно было отличить его от метода экземпляра класса. + # Он может быть вызван только на уровне класса, но не экземпляра. + def self.say(msg) + puts "#{msg}" + end + + def species + @@species + end + +end + + +# Создание экземпляра класса +jim = Human.new("Jim Halpert") + +dwight = Human.new("Dwight K. Schrute") + +# Давайте вызовем несколько методов +jim.species #=> "H. sapiens" +jim.name #=> "Jim Halpert" +jim.name = "Jim Halpert II" #=> "Jim Halpert II" +jim.name #=> "Jim Halpert II" +dwight.species #=> "H. sapiens" +dwight.name #=> "Dwight K. Schrute" + +# Вызов метода класса +Human.say("Hi") #=> "Hi" + +# Область видимости переменной определяется тем, как мы даём имя переменной. +# Переменные, имя которых начинается с "$" имеют глобальную область видимости +$var = "I'm a global var" +defined? $var #=> "global-variable" + +# Переменная экземпляра класса, она видна только в экземпляре +@var = "I'm an instance var" +defined? @var #=> "instance-variable" + +# Переменная класса, видна для всех экземпляров этого класса и в самом классе +@@var = "I'm a class var" +defined? @@var #=> "class variable" + +# Имена переменных с большой буквы используются для создания констант +Var = "I'm a constant" +defined? Var #=> "constant" + +# Класс тоже объект в Ruby. Класс может иметь переменные экземпляра. +# Переменная класса доступна в классе, его экземплярах и его потомках. + +# Пример класса +class Human + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(value) + @@foo = value + end +end + +# Производный класс (класс-потомок) +class Worker < Human +end + +Human.foo # 0 +Worker.foo # 0 + +Human.foo = 2 # 2 +Worker.foo # 2 + +# Переменная экземпляра класса недоступна в потомках этого класса. + +class Human + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(value) + @bar = value + end +end + +class Doctor < Human +end + +Human.bar # 0 +Doctor.bar # nil + +module ModuleExample + def foo + 'foo' + end +end + +# Включение модулей в класс добавляет их методы в экземпляр класса +# Или в сам класс, зависит только от метода подключения +class Person + include ModuleExample +end + +class Book + extend ModuleExample +end + +Person.foo # => NoMethodError: undefined method `foo' for Person:Class +Person.new.foo # => 'foo' +Book.foo # => 'foo' +Book.new.foo # => NoMethodError: undefined method `foo' + +# Коллбэки при подключении модуля + +module ConcernExample + def self.included(base) + base.extend(ClassMethods) + base.send(:include, InstanceMethods) + end + + module ClassMethods + def bar + 'bar' + end + end + + module InstanceMethods + def qux + 'qux' + end + end +end + +class Something + include ConcernExample +end + +Something.bar # => 'bar' +Something.qux # => NoMethodError: undefined method `qux' +Something.new.bar # => NoMethodError: undefined method `bar' +Something.new.qux # => 'qux' +``` diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown new file mode 100644 index 00000000..77987bb3 --- /dev/null +++ b/ru-ru/swift-ru.html.markdown @@ -0,0 +1,589 @@ +--- +language: swift +contributors: + - ["Grant Timmerman", "http://github.com/grant"] + - ["Christopher Bess", "http://github.com/cbess"] + - ["Joey Huang", "http://github.com/kamidox"] +filename: learnswift-ru.swift +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +Swift - это язык программирования, созданный компанией Apple, для приложений +под iOS и OS X. Разработанный, чтобы сосуществовать с Objective-C и +быть более устойчивым к ошибочному коду, Swift был представлен в 2014 году на +конференции разработчиков Apple, WWDC. Приложения на Swift собираются +с помощью LLVM-компилятора, включенного в Xcode 6+. + +Официальная книга по [языку программирования Swift](https://itunes.apple.com/us/book/swift-programming-language/id881256329) от Apple доступна в iBooks. + +Смотрите еще [начальное руководство](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html) Apple, которое содержит полное учебное пособие по Swift. + +```swift +// импорт модуля +import UIKit + +// +// MARK: Основы +// + +// Xcode поддерживает маркеры, чтобы давать примечания своему коду +// и вносить их в список обозревателя (Jump Bar) +// MARK: Метка раздела +// TODO: Сделайте что-нибудь вскоре +// FIXME: Исправьте этот код + +println("Привет, мир") + +// переменные (var), значение которых можно изменить после инициализации +// константы (let), значение которых нельзя изменить после инициализации + +var myVariable = 42 +let øπΩ = "значение" // именование переменной символами unicode +let π = 3.1415926 +let convenience = "Ключевое слово" // контекстное имя переменной +let weak = "Ключевое слово"; let override = "еще ключевое слово" // операторы + // могут быть отделены точкой с запятой +let `class` = "Ключевое слово" // обратные апострофы позволяют использовать + // ключевые слова в именовании переменных +let explicitDouble: Double = 70 +let intValue = 0007 // 7 +let largeIntValue = 77_000 // 77000 +let label = "некоторый текст " + String(myVariable) // Приведение типа +let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Вставка переменных в строку + +// Сборка особых значений +// используя ключ -D сборки конфигурации +#if false + println("Не печатается") + let buildValue = 3 +#else + let buildValue = 7 +#endif +println("Значение сборки: \(buildValue)") // Значение сборки: 7 + +/* + Опционалы - это особенность языка Swift, которая допускает вам сохранять + `некоторое` или `никакое` значения. + + Язык Swift требует, чтобы каждое свойство имело значение, поэтому даже nil + должен быть явно сохранен как опциональное значение. + + Optional<T> является перечислением. +*/ +var someOptionalString: String? = "опционал" // Может быть nil +// как и выше, только ? - это постфиксный оператор (синтаксический сахар) +var someOptionalString2: Optional<String> = "опционал" + +if someOptionalString != nil { + // я не nil + if someOptionalString!.hasPrefix("opt") { + println("содержит префикс") + } + + let empty = someOptionalString?.isEmpty +} +someOptionalString = nil + +// неявная развертка опциональной переменной +var unwrappedString: String! = "Ожидаемое значение." +// как и выше, только ! - постфиксный оператор (с еще одним синтаксическим сахаром) +var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Ожидаемое значение." + +if let someOptionalStringConstant = someOptionalString { + // имеется некоторое значение, не nil + if !someOptionalStringConstant.hasPrefix("ok") { + // нет такого префикса + } +} + +// Swift поддерживает сохранение значения любого типа +// AnyObject == id +// В отличие от `id` в Objective-C, AnyObject работает с любым значением (Class, +// Int, struct и т.д.) +var anyObjectVar: AnyObject = 7 +anyObjectVar = "Изменять значение на строку не является хорошей практикой, но возможно." + +/* + Комментируйте здесь + + /* + Вложенные комментарии тоже поддерживаются + */ +*/ + +// +// MARK: Коллекции +// + +/* + Массив (Array) и словарь (Dictionary) являются структурами (struct). Так + `let` и `var` также означают, что они изменяются (var) или не изменяются (let) + при объявлении переменных этих типов. +*/ + +// Массив +var shoppingList = ["сом", "вода", "лимоны"] +shoppingList[1] = "бутылка воды" +let emptyArray = [String]() // let == неизменный +let emptyArray2 = Array<String>() // как и выше +var emptyMutableArray = [String]() // var == изменяемый + + +// Словарь +var occupations = [ + "Malcolm": "Капитан", + "kaylee": "Техник" +] +occupations["Jayne"] = "Связи с общественностью" +let emptyDictionary = [String: Float]() // let == неизменный +let emptyDictionary2 = Dictionary<String, Float>() // как и выше +var emptyMutableDictionary = [String: Float]() // var == изменяемый + + +// +// MARK: Поток управления +// + +// цикл for для массива +let myArray = [1, 1, 2, 3, 5] +for value in myArray { + if value == 1 { + println("Один!") + } else { + println("Не один!") + } +} + +// цикл for для словаря +var dict = ["один": 1, "два": 2] +for (key, value) in dict { + println("\(key): \(value)") +} + +// цикл for для диапазона чисел +for i in -1...shoppingList.count { + println(i) +} +shoppingList[1...2] = ["бифштекс", "орехи пекан"] +// используйте ..< для исключения последнего числа + +// цикл while +var i = 1 +while i < 1000 { + i *= 2 +} + +// цикл do-while +do { + println("привет") +} while 1 == 2 + +// Переключатель +// Очень мощный оператор, представляйте себе операторы `if` с синтаксическим +// сахаром +// Они поддерживают строки, объекты и примитивы (Int, Double, etc) +let vegetable = "красный перец" +switch vegetable { +case "сельдерей": + let vegetableComment = "Добавьте немного изюма, имитируя муравьев на бревнышке." +case "огурец", "кресс-салат": + let vegetableComment = "Было бы неплохо сделать бутерброд с чаем." +case let localScopeValue where localScopeValue.hasSuffix("перец"): + let vegetableComment = "Это острый \(localScopeValue)?" +default: // обязательный (чтобы предусмотреть все возможные вхождения) + let vegetableComment = "В супе все овощи вкусные." +} + + +// +// MARK: Функции +// + +// Функции являются типом первого класса, т.е. они могут быть вложены в функциях +// и могут передаваться между собой + +// Функция с документированным заголовком Swift (формат reStructedText) + +/** + Операция приветствия + + - Маркер в документировании + - Еще один маркер в документации + + :param: name - это имя + :param: day - это день + :returns: Строка, содержащая значения name и day. +*/ +func greet(name: String, day: String) -> String { + return "Привет \(name), сегодня \(day)." +} +greet("Боб", "вторник") + +// как и выше, кроме обращения параметров функции +func greet2(#requiredName: String, externalParamName localParamName: String) -> String { + return "Привет \(requiredName), сегодня \(localParamName)" +} +greet2(requiredName:"Иван", externalParamName: "воскресенье") + +// Функция, которая возвращает множество элементов в кортеже +func getGasPrices() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let pricesTuple = getGasPrices() +let price = pricesTuple.2 // 3.79 +// Пропускайте значения кортежей с помощью подчеркивания _ +let (_, price1, _) = pricesTuple // price1 == 3.69 +println(price1 == pricesTuple.1) // вывод: true +println("Цена газа: \(price)") + +// Переменное число аргументов +func setup(numbers: Int...) { + // это массив + let number = numbers[0] + let argCount = numbers.count +} + +// Передача и возврат функций +func makeIncrementer() -> (Int -> Int) { + func addOne(number: Int) -> Int { + return 1 + number + } + return addOne +} +var increment = makeIncrementer() +increment(7) + +// передача по ссылке +func swapTwoInts(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +swapTwoInts(&someIntA, &someIntB) +println(someIntB) // 7 + + +// +// MARK: Замыкания +// +var numbers = [1, 2, 6] + +// Функции - это частный случай замыканий ({}) + +// Пример замыкания. +// `->` отделяет аргументы и возвращаемый тип +// `in` отделяет заголовок замыкания от тела замыкания +numbers.map({ + (number: Int) -> Int in + let result = 3 * number + return result +}) + +// Когда тип известен, как и выше, мы можем сделать так +numbers = numbers.map({ number in 3 * number }) +// Или даже так +//numbers = numbers.map({ $0 * 3 }) + +print(numbers) // [3, 6, 18] + +// Хвостовое замыкание +numbers = sorted(numbers) { $0 > $1 } + +print(numbers) // [18, 6, 3] + +// Суперсокращение, поскольку оператор < выполняет логический вывод типов + +numbers = sorted(numbers, < ) + +print(numbers) // [3, 6, 18] + +// +// MARK: Структуры +// + +// Структуры и классы имеют очень похожие характеристики +struct NamesTable { + let names = [String]() + + // Пользовательский индекс + subscript(index: Int) -> String { + return names[index] + } +} + +// У структур автогенерируемый (неявно) инициализатор +let namesTable = NamesTable(names: ["Me", "Them"]) +let name = namesTable[1] +println("Name is \(name)") // Name is Them + +// +// MARK: Классы +// + +// Классы, структуры и их члены имеют трехуровневый контроль доступа +// Уровни: internal (по умолчанию), public, private + +public class Shape { + public func getArea() -> Int { + return 0; + } +} + +// Все методы и свойства класса являются открытыми (public). +// Если вам необходимо содержать только данные +// в структурированном объекте, вы должны использовать `struct` + +internal class Rect: Shape { + var sideLength: Int = 1 + + // Пользовательский сеттер и геттер + private var perimeter: Int { + get { + return 4 * sideLength + } + set { + // `newValue` - неявная переменная, доступная в сеттере + sideLength = newValue / 4 + } + } + + // Ленивая загрузка свойства + // свойство subShape остается равным nil (неинициализированным), + // пока не вызовется геттер + lazy var subShape = Rect(sideLength: 4) + + // Если вам не нужны пользовательские геттеры и сеттеры, + // но все же хотите запустить код перед и после вызовов геттера или сеттера + // свойств, вы можете использовать `willSet` и `didSet` + var identifier: String = "defaultID" { + // аргумент у `willSet` будет именем переменной для нового значения + willSet(someIdentifier) { + print(someIdentifier) + } + } + + init(sideLength: Int) { + self.sideLength = sideLength + // последним всегда вызывается super.init, когда init с параметрами + super.init() + } + + func shrink() { + if sideLength > 0 { + --sideLength + } + } + + override func getArea() -> Int { + return sideLength * sideLength + } +} + +// Простой класс `Square` наследует `Rect` +class Square: Rect { + convenience init() { + self.init(sideLength: 5) + } +} + +var mySquare = Square() +print(mySquare.getArea()) // 25 +mySquare.shrink() +print(mySquare.sideLength) // 4 + +// преобразование объектов +let aShape = mySquare as Shape + +// сравнение экземпляров, в отличие от ==, которая проверяет эквивалентность +if mySquare === mySquare { + println("Ага, это mySquare") +} + +// Опциональная инициализация (init) +class Circle: Shape { + var radius: Int + override func getArea() -> Int { + return 3 * radius * radius + } + + // Поместите постфиксный знак вопроса после `init` - это и будет опциональная инициализация, + // которая может вернуть nil + init?(radius: Int) { + self.radius = radius + super.init() + + if radius <= 0 { + return nil + } + } +} + +var myCircle = Circle(radius: 1) +println(myCircle?.getArea()) // Optional(3) +println(myCircle!.getArea()) // 3 +var myEmptyCircle = Circle(radius: -1) +println(myEmptyCircle?.getArea()) // "nil" +if let circle = myEmptyCircle { + // не будет выполняться, поскольку myEmptyCircle равен nil + println("circle не nil") +} + + +// +// MARK: Перечисления +// + +// Перечисления могут быть определенного или своего типа. +// Они могут содержать методы подобно классам. + +enum Suit { + case Spades, Hearts, Diamonds, Clubs + func getIcon() -> String { + switch self { + case .Spades: return "♤" + case .Hearts: return "♡" + case .Diamonds: return "♢" + case .Clubs: return "♧" + } + } +} + +// Значения перечислений допускают сокращенный синтаксис, нет необходимости +// указывать тип перечисления, когда переменная объявляется явно +var suitValue: Suit = .Hearts + +// Нецелочисленные перечисления требуют прямого указания значений +enum BookName: String { + case John = "Иоанн" + case Luke = "Лука" +} +println("Имя: \(BookName.John.rawValue)") + +// Перечисление (enum) со связанными значениями +enum Furniture { + // Связать с типом Int + case Desk(height: Int) + // Связать с типами String и Int + case Chair(String, Int) + + func description() -> String { + switch self { + case .Desk(let height): + return "Письменный стол высотой \(height) см." + case .Chair(let brand, let height): + return "Стул марки \(brand) высотой \(height) см." + } + } +} + +var desk: Furniture = .Desk(height: 80) +println(desk.description()) // "Письменный стол высотой 80 см." +var chair = Furniture.Chair("Foo", 40) +println(chair.description()) // "Стул марки Foo высотой 40 см." + + +// +// MARK: Протоколы +// + +// `protocol` может потребовать, чтобы у соответствующих типов +// были определенные свойства экземпляра, методы экземпляра, тип методов, +// операторы и индексы. + +protocol ShapeGenerator { + var enabled: Bool { get set } + func buildShape() -> Shape +} + +// Протоколы, объявленные с @objc, допускают необязательные функции, +// которые позволяют вам проверять на соответствие +@objc protocol TransformShape { + optional func reshaped() + optional func canReshape() -> Bool +} + +class MyShape: Rect { + var delegate: TransformShape? + + func grow() { + sideLength += 2 + // Размещайте знак вопроса перед опционным свойством, методом + // или индексом, чтобы не учитывать nil-значение и возвратить nil + // вместо выбрасывания ошибки выполнения (т.н. "опционная цепочка") + if let allow = self.delegate?.canReshape?() { + // проверка делегата на выполнение метода + self.delegate?.reshaped?() + } + } +} + + +// +// MARK: Прочее +// + +// `extension`s: Добавляет расширенный функционал к существующему типу + +// Класс Square теперь "соответствует" протоколу `Printable` +extension Square: Printable { + var description: String { + return "Площадь: \(self.getArea()) - ID: \(self.identifier)" + } +} + +println("Объект Square: \(mySquare)") + +// Вы также можете расширить встроенные типы +extension Int { + var customProperty: String { + return "Это \(self)" + } + + func multiplyBy(num: Int) -> Int { + return num * self + } +} + +println(7.customProperty) // "Это 7" +println(14.multiplyBy(3)) // 42 + +// Обобщения: Подобно языкам Java и C#. Используйте ключевое слово `where`, +// чтобы определить условия обобщений. + +func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { + for (index, value) in enumerate(array) { + if value == valueToFind { + return index + } + } + return nil +} +let foundAtIndex = findIndex([1, 2, 3, 4], 3) +println(foundAtIndex == 2) // вывод: true + +// Операторы: +// Пользовательские операторы могут начинаться с символов: +// / = - + * % < > ! & | ^ . ~ +// или +// Unicode- знаков математики, символов, стрелок, декорации и линий/кубов, +// нарисованных символов. +prefix operator !!! {} + +// Префиксный оператор, который утраивает длину стороны, когда используется +prefix func !!! (inout shape: Square) -> Square { + shape.sideLength *= 3 + return shape +} + +// текущее значение +println(mySquare.sideLength) // 4 + +// Используя пользовательский оператор !!!, изменится длина стороны +// путем увеличения размера в 3 раза +!!!mySquare +println(mySquare.sideLength) // 12 +``` diff --git a/ru-ru/xml-ru.html.markdown b/ru-ru/xml-ru.html.markdown new file mode 100644 index 00000000..b0096b75 --- /dev/null +++ b/ru-ru/xml-ru.html.markdown @@ -0,0 +1,130 @@ +--- +language: xml +filename: learnxml-ru.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +XML - это язык разметки, предназначенный для хранения и передачи данных. + +В отличие от HTML, XML не определяет, как отображать или форматировать данные, он только содержит их. + +* XML-Синтаксис + +```xml +<!-- Комментарии в XML выглядят вот так --> + +<?xml version="1.0" encoding="UTF-8"?> +<bookstore> + <book category="КУЛИНАРИЯ"> + <title lang="ru">Итальянская кухня каждый день</title> + <author>Giada De Laurentiis</author> + <year>2005</year> + <price>30.00</price> + </book> + <book category="ДЕТИ"> + <title lang="ru">Гарри Поттер</title> + <author>Дж. К. Роулинг</author> + <year>2005</year> + <price>29.99</price> + </book> + <book category="ВСЕМИРНАЯ ПАУТИНА"> + <title lang="ru">Изучаем XML</title> + <author>Эрик Рэй</author> + <year>2003</year> + <price>39.95</price> + </book> +</bookstore> + +<!-- Вышеописанный документ - типичный XML-файл. + Он начинается с определения, объявляющего о некоторых метаданных (необязательно). + + XML использует древовидную структуру. У вышеописанного документа + корневой узел - 'bookstore', который содержит три дочерних узла - все 'book'-узлы. + Такие узлы содержат еще дочерние узлы и т.д. + + Узлы создаются с помощью открывающих/закрывающих тегов, + а дочерние узлы - это узлы между открывающимися и закрывающимися тегами.--> + + +<!-- XML содержит в себе два типа данных: + 1 - Атрибуты -> Это метаданные узлов. + Обычно XML-парсер использует эту информацию, чтобы хранить свойства данных. + Атрибут изображается путем вписывания его в скобки в пределах открытого тега + 2 - Элементы -> Это чистые данные. + Это то, что парсер извлечет из XML-файла. + Элементы идут между открытыми и закрытыми тегами без скобок. --> + + +<!-- Ниже элемент с двумя атрибутами --> +<file type="gif" id="4293">компьютер.gif</file> + + +``` + +* Хорошо отформатированный документ x Проверка достоверности + +XML-документ хорошо отформатирован, если он синтаксически верный. +Впрочем, в документ возможно ввести больше ограничений, +используя определения документа, вроде DTD и XML-схемы. + +XML-документ, который следует описанию документа, называется корректным, +относительно этого документа. + +С таким инструментом вы можете проверить XML-данные вне логики приложения. + +```xml + +<!-- Ниже вы можете увидеть упрощенную версию документа книжного магазина, + с дополнением DTD-определения.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Bookstore.dtd"> +<bookstore> + <book category="КУЛИНАРИЯ"> + <title >Итальянская кухня каждый день</title> + <price>30.00</price> + </book> +</bookstore> + +<!-- Этот DTD может быть чем-то вроде:--> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Литература"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + + +<!-- DTD начинается с объявления. + Затем объявляется корневой узел, требующий 1 или более дочерних узлов 'book'. + Каждый 'book' должен содержать точно один 'title' и 'price', и атрибут, + называемый 'category', со значением "Литература" по умолчанию. + Узлы 'title' и 'price' содержат анализируемые символьные данные.--> + +<!-- DTD может быть объявлен в самом XML-файле.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Литература"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + +<bookstore> + <book category="КУЛИНАРИЯ"> + <title >Итальянская кухня каждый день</title> + <price>30.00</price> + </book> +</bookstore> +``` diff --git a/ruby-ecosystem.html.markdown b/ruby-ecosystem.html.markdown new file mode 100644 index 00000000..1fbcc752 --- /dev/null +++ b/ruby-ecosystem.html.markdown @@ -0,0 +1,138 @@ +--- +category: tool +tool: ruby ecosystem +contributors: + - ["Jon Smock", "http://github.com/jonsmock"] + - ["Rafal Chmiel", "http://github.com/rafalchmiel"] + +--- + +People using Ruby generally have a way to install different Ruby versions, +manage their packages (or gems), and manage their gem dependencies. + +## Ruby Managers + +Some platforms have Ruby pre-installed or available as a package. Most rubyists +do not use these, or if they do, they only use them to bootstrap another Ruby +installer or implementation. Instead rubyists tend to install a Ruby manager to +install and switch between many versions of Ruby and their projects' Ruby +environments. + +The following are the popular Ruby environment managers: + +* [RVM](https://rvm.io/) - Installs and switches between rubies. RVM also has + the concept of gemsets to isolate projects' environments completely. +* [ruby-build](https://github.com/sstephenson/ruby-build) - Only installs + rubies. Use this for finer control over your rubies' installations. +* [rbenv](https://github.com/sstephenson/rbenv) - Only switches between rubies. + Used with ruby-build. Use this for finer control over how rubies load. +* [chruby](https://github.com/postmodern/chruby) - Only switches between rubies. + Similar in spirit to rbenv. Unopinionated about how rubies are installed. + +## Ruby Versions + +Ruby was created by Yukihiro "Matz" Matsumoto, who remains somewhat of a +[BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), although +that is changing recently. As a result, the reference implementation of Ruby is +called MRI (Matz' Reference Implementation), and when you hear a Ruby version, +it is referring to the release version of MRI. + +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. 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/). + +The change between 1.8.7 to 1.9.x is a much larger change than 1.9.3 to 2.0.0. +For instance, the 1.9 series introduced encodings and a bytecode VM. There +are projects still on 1.8.7, but they are becoming a small minority, as most of +the community has moved to at least 1.9.2 or 1.9.3. + +## Ruby Implementations + +The Ruby ecosystem enjoys many different implementations of Ruby, each with +unique strengths and states of compatibility. To be clear, the different +implementations are written in different languages, but *they are all Ruby*. +Each implementation has special hooks and extra features, but they all run +normal Ruby files well. For instance, JRuby is written in Java, but you do +not need to know Java to use it. + +Very mature/compatible: + +* [MRI](https://github.com/ruby/ruby) - Written in C, this is the reference implementation of Ruby. By + definition it is 100% compatible (with itself). All other rubies +maintain compatibility with MRI (see [RubySpec](#rubyspec) below). +* [JRuby](http://jruby.org/) - Written in Java and Ruby, this robust implementation is quite fast. + Most importantly, JRuby's strength is JVM/Java interop, leveraging existing +JVM tools, projects, and languages. +* [Rubinius](http://rubini.us/) - Written primarily in Ruby itself with a C++ bytecode VM. Also + mature and fast. Because it is implemented in Ruby itself, it exposes many VM +features into rubyland. + +Medium mature/compatible: + +* [Maglev](http://maglev.github.io/) - Built on top of Gemstone, a Smalltalk VM. Smalltalk has some + impressive tooling, and this project tries to bring that into Ruby +development. +* [RubyMotion](http://www.rubymotion.com/) - Brings Ruby to iOS development. + +Less mature/compatible: + +* [Topaz](http://topazruby.com/) - Written in RPython (using the PyPy toolchain), Topaz is fairly young + and not yet compatible. It shows promise to be a high-performance Ruby +implementation. +* [IronRuby](http://ironruby.net/) - Written in C# targeting the .NET platform, work on IronRuby seems + to have stopped since Microsoft pulled their support. + +Ruby implementations may have their own release version numbers, but they always +target a specific version of MRI for compatability. Many implementations have +the ability to enter different modes (for example, 1.8 or 1.9 mode) to specify +which MRI version to target. + +## RubySpec + +Most Ruby implementations rely heavily on [RubySpec](http://rubyspec.org/). Ruby +has no official specification, so the community has written executable specs in +Ruby to test their implementations' compatibility with MRI. + +## RubyGems + +[RubyGems](http://rubygems.org/) is a community-run package manager for Ruby. +RubyGems ships with Ruby, so there is no need to download it separately. + +Ruby packages are called "gems," and they can be hosted by the community at +RubyGems.org. Each gem contains its source code and some metadata, including +things like version, dependencies, author(s), and license(s). + +## Bundler + +[Bundler](http://bundler.io/) is a gem dependency resolver. It uses a project's +Gemfile to find dependencies, and then fetches those dependencies' dependencies +recursively. It does this until all dependencies are resolved and downloaded, or +it will stop if a conflict has been found. + +Bundler will raise an error if it finds conflicting dependencies. For example, +if gem A requires version 3 or greater of gem Z, but gem B requires version 2, +Bundler will notify you of the conflict. This becomes extremely helpful as many +gems refer to other gems (which refer to other gems), which can form a large +dependency graph to resolve. + +# Testing + +Testing is a large part of Ruby culture. Ruby comes with its own Unit-style +testing framework called minitest (Or TestUnit for Ruby version 1.8.x). There +are many testing libraries with different goals. + +* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Ruby 1.8's built-in "Unit-style" testing framework +* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Ruby 1.9/2.0's built-in testing framework +* [RSpec](http://rspec.info/) - A testing framework that focuses on expressivity +* [Cucumber](http://cukes.info/) - A BDD testing framework that parses Gherkin formatted tests + +## Be Nice + +The Ruby community takes pride in being an open, diverse, welcoming community. +Matz himself is extremely friendly, and the generosity of rubyists on the whole +is amazing. diff --git a/ruby.html.markdown b/ruby.html.markdown index 38d060a3..8f23b2e6 100644 --- a/ruby.html.markdown +++ b/ruby.html.markdown @@ -4,6 +4,15 @@ filename: learnruby.rb contributors: - ["David Underwood", "http://theflyingdeveloper.com"] - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] + - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"] + - ["Ariel Krakowski", "http://www.learneroo.com"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] + - ["Levi Bostian", "https://github.com/levibostian"] + - ["Rahil Momin", "https://github.com/iamrahil"] + --- ```ruby @@ -29,6 +38,12 @@ You shouldn't either 8 - 1 #=> 7 10 * 2 #=> 20 35 / 5 #=> 7 +2**5 #=> 32 + +# Arithmetic is just syntactic sugar +# for calling a method on an object +1.+(3) #=> 4 +10.* 5 #=> 50 # Special values are objects nil # Nothing to see here @@ -46,8 +61,6 @@ false.class #=> FalseClass # Inequality 1 != 1 #=> false 2 != 1 #=> true -!true #=> false -!false #=> true # apart from false itself, nil is the only other 'falsey' value @@ -61,15 +74,37 @@ false.class #=> FalseClass 2 <= 2 #=> true 2 >= 2 #=> true +# Logical operators +true && false #=> false +true || false #=> true +!true #=> false + +# There are alternate versions of the logical operators with much lower +# precedence. These are meant to be used as flow-control constructs to chain +# statements together until one of them returns true or false. + +# `do_something_else` only called if `do_something` succeeds. +do_something() and do_something_else() +# `log_error` only called if `do_something` fails. +do_something() or log_error() + + # Strings are objects 'I am a string'.class #=> String "I am a string too".class #=> String -placeholder = "use string interpolation" +placeholder = 'use string interpolation' "I can #{placeholder} when using double quoted strings" #=> "I can use string interpolation when using double quoted strings" +# Prefer single quoted strings to double quoted ones where possible +# Double quoted strings perform additional inner calculations + +# Combine strings, but not with numbers +'hello ' + 'world' #=> "hello world" +'hello ' + 3 #=> TypeError: can't convert Fixnum into String +'hello ' + 3.to_s #=> "hello 3" # print to the output puts "I'm printing!" @@ -110,32 +145,47 @@ status == :approved #=> false # Arrays # This is an array -[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] # Arrays can contain different types of items -array = [1, "hello", false] #=> => [1, "hello", false] +[1, 'hello', false] #=> [1, "hello", false] # Arrays can be indexed # From the front array[0] #=> 1 array[12] #=> nil +# Like arithmetic, [var] access +# is just syntactic sugar +# for calling a method [] on an object +array.[] 0 #=> 1 +array.[] 12 #=> nil + # From the end array[-1] #=> 5 -# With a start and end index -array[2, 4] #=> [3, 4, 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] # Add to an array like this array << 6 #=> [1, 2, 3, 4, 5, 6] +# Or like this +array.push(6) #=> [1, 2, 3, 4, 5, 6] + +# Check if an item exists in an array +array.include?(1) #=> true # Hashes are Ruby's primary dictionary with keys/value pairs. # Hashes are denoted with curly braces: -hash = {'color' => 'green', 'number' => 5} +hash = { 'color' => 'green', 'number' => 5 } hash.keys #=> ['color', 'number'] @@ -146,28 +196,27 @@ hash['number'] #=> 5 # Asking a hash for a key that doesn't exist returns nil: hash['nothing here'] #=> nil -# Iterate over hashes with the #each method: -hash.each do |k, v| - puts "#{k} is #{v}" -end - # Since Ruby 1.9, there's a special syntax when using symbols as keys: -new_hash = { defcon: 3, action: true} +new_hash = { defcon: 3, action: true } new_hash.keys #=> [:defcon, :action] +# Check existence of keys and values in hash +new_hash.has_key?(:defcon) #=> true +new_hash.has_value?(3) #=> true + # Tip: Both Arrays and Hashes are Enumerable # They share a lot of useful methods such as each, map, count, and more # Control structures if true - "if statement" + 'if statement' elsif false - "else if, optional" + 'else if, optional' else - "else, also optional" + 'else, also optional' end for counter in 1..5 @@ -179,9 +228,15 @@ end #=> iteration 4 #=> iteration 5 -# HOWEVER -# No-one uses for loops -# Use `each` instead, like this: +# HOWEVER, No-one uses for loops. +# Instead you should use the "each" method and pass it a block. +# A block is a bunch of code that you can pass to a method like "each". +# It is analogous to lambdas, anonymous functions or closures in other +# programming languages. +# +# The "each" method of a range runs the block once for each element of the range. +# The block is passed a counter as a parameter. +# Calling the "each" method with a block looks like this: (1..5).each do |counter| puts "iteration #{counter}" @@ -192,6 +247,17 @@ end #=> iteration 4 #=> iteration 5 +# You can also surround blocks in curly brackets: +(1..5).each { |counter| puts "iteration #{counter}" } + +# The contents of data structures can also be iterated using each. +array.each do |element| + puts "#{element} is part of the array" +end +hash.each do |key, value| + puts "#{key} is #{value}" +end + counter = 1 while counter <= 5 do puts "iteration #{counter}" @@ -207,17 +273,44 @@ grade = 'B' case grade when 'A' - puts "Way to go kiddo" + puts 'Way to go kiddo' when 'B' - puts "Better luck next time" + puts 'Better luck next time' when 'C' - puts "You can do better" + puts 'You can do better' when 'D' - puts "Scraping through" + puts 'Scraping through' when 'F' - puts "You failed!" -else - puts "Alternative grading system, eh?" + puts 'You failed!' +else + puts 'Alternative grading system, eh?' +end +#=> "Better luck next time" + +# cases can also use ranges +grade = 82 +case grade +when 90..100 + puts 'Hooray!' +when 80...90 + puts 'OK job' +else + puts 'You failed!' +end +#=> "OK job" + +# exception handling: +begin + # code here that might raise an exception + raise NoMemoryError, 'You ran out of memory.' +rescue NoMemoryError => exception_variable + puts 'NoMemoryError was raised', exception_variable +rescue RuntimeError => other_exception_variable + puts 'RuntimeError was raised now' +else + puts 'This runs if no exceptions were thrown at all' +ensure + puts 'This code always runs no matter what' end # Functions @@ -226,7 +319,7 @@ def double(x) x * 2 end -# Functions (and all blocks) implcitly return the value of the last statement +# Functions (and all blocks) implicitly return the value of the last statement double(2) #=> 4 # Parentheses are optional where the result is unambiguous @@ -234,23 +327,23 @@ double 3 #=> 6 double double 3 #=> 12 -def sum(x,y) +def sum(x, y) x + y end # Method arguments are separated by a comma sum 3, 4 #=> 7 -sum sum(3,4), 5 #=> 12 +sum sum(3, 4), 5 #=> 12 # yield # All methods have an implicit, optional block parameter # it can be called with the 'yield' keyword def surround - puts "{" + puts '{' yield - puts "}" + puts '}' end surround { puts 'hello world' } @@ -260,47 +353,65 @@ surround { puts 'hello world' } # } -# Define a class with the class keyword -class Human - - # A class variable. It is shared by all instances of this class. - @@species = "H. sapiens" - - # Basic initializer - def initialize(name, age=0) - # Assign the argument to the "name" instance variable for the instance - @name = name - # If no age given, we will fall back to the default in the arguments list. - @age = age - end - - # Basic setter method - def name=(name) - @name = name - end - - # Basic getter method - def name - @name - end +# You can pass a block to a function +# "&" marks a reference to a passed block +def guests(&block) + block.call 'some_argument' +end - # A class method uses self to distinguish from instance methods. - # It can only be called on the class, not an instance. - def self.say(msg) - puts "#{msg}" - end +# You can pass a list of arguments, which will be converted into an array +# That's what splat operator ("*") is for +def guests(*array) + array.each { |guest| puts guest } +end - def species - @@species - end +# Define a class with the class keyword +class Human + # A class variable. It is shared by all instances of this class. + @@species = 'H. sapiens' + + # Basic initializer + def initialize(name, age = 0) + # Assign the argument to the "name" instance variable for the instance + @name = name + # If no age given, we will fall back to the default in the arguments list. + @age = age + end + + # Basic setter method + def name=(name) + @name = name + end + + # Basic getter method + def name + @name + end + + # The above functionality can be encapsulated using the attr_accessor method as follows + attr_accessor :name + + # Getter/setter methods can also be created individually like this + attr_reader :name + attr_writer :name + + # A class method uses self to distinguish from instance methods. + # It can only be called on the class, not an instance. + def self.say(msg) + puts msg + end + + def species + @@species + end end # Instantiate a class -jim = Human.new("Jim Halpert") +jim = Human.new('Jim Halpert') -dwight = Human.new("Dwight K. Schrute") +dwight = Human.new('Dwight K. Schrute') # Let's call a couple of methods jim.species #=> "H. sapiens" @@ -311,5 +422,128 @@ dwight.species #=> "H. sapiens" dwight.name #=> "Dwight K. Schrute" # Call the class method -Human.say("Hi") #=> "Hi" +Human.say('Hi') #=> "Hi" + +# Variable's scopes are defined by the way we name them. +# Variables that start with $ have global scope +$var = "I'm a global var" +defined? $var #=> "global-variable" + +# Variables that start with @ have instance scope +@var = "I'm an instance var" +defined? @var #=> "instance-variable" + +# Variables that start with @@ have class scope +@@var = "I'm a class var" +defined? @@var #=> "class variable" + +# Variables that start with a capital letter are constants +Var = "I'm a constant" +defined? Var #=> "constant" + +# Class is also an object in ruby. So class can have instance variables. +# Class variable is shared among the class and all of its descendants. + +# base class +class Human + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(value) + @@foo = value + end +end + +# derived class +class Worker < Human +end + +Human.foo # 0 +Worker.foo # 0 + +Human.foo = 2 # 2 +Worker.foo # 2 + +# Class instance variable is not shared by the class's descendants. + +class Human + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(value) + @bar = value + end +end + +class Doctor < Human +end + +Human.bar # 0 +Doctor.bar # nil + +module ModuleExample + def foo + 'foo' + end +end + +# Including modules binds their methods to the class instances +# Extending modules binds their methods to the class itself + +class Person + include ModuleExample +end + +class Book + extend ModuleExample +end + +Person.foo # => NoMethodError: undefined method `foo' for Person:Class +Person.new.foo # => 'foo' +Book.foo # => 'foo' +Book.new.foo # => NoMethodError: undefined method `foo' + +# Callbacks are executed when including and extending a module + +module ConcernExample + def self.included(base) + base.extend(ClassMethods) + base.send(:include, InstanceMethods) + end + + module ClassMethods + def bar + 'bar' + end + end + + module InstanceMethods + def qux + 'qux' + end + end +end + +class Something + include ConcernExample +end + +Something.bar # => 'bar' +Something.qux # => NoMethodError: undefined method `qux' +Something.new.bar # => NoMethodError: undefined method `bar' +Something.new.qux # => 'qux' ``` + +## Additional resources + +- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges. +- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) +- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide. diff --git a/rust.html.markdown b/rust.html.markdown new file mode 100644 index 00000000..b2854b0c --- /dev/null +++ b/rust.html.markdown @@ -0,0 +1,307 @@ +--- +language: rust +contributors: + - ["P1start", "http://p1start.github.io/"] +filename: learnrust.rs +--- + +Rust is a programming language developed by Mozilla Research. +Rust combines low-level control over performance with high-level convenience and +safety guarantees. + +It achieves these goals without requiring a garbage collector or runtime, making +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 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 +currently available in the nightly builds. Rust has adopted a train-based release +model with regular releases every six weeks. Rust 1.1 beta was made available at +the same time of the release of Rust 1.0. + +Although Rust is a relatively low-level language, Rust has some functional +concepts that are generally found in higher-level languages. This makes +Rust not only fast, but also easy and efficient to code in. + +```rust +// This is a comment. Single-line look like this... +/* ...and multi-line comment look like this */ + +/////////////// +// 1. Basics // +/////////////// + +// Functions +// `i32` is the type for 32-bit signed integers +fn add2(x: i32, y: i32) -> i32 { + // Implicit return (no semicolon) + x + y +} + +// Main function +fn main() { + // Numbers // + + // Immutable bindings + let x: i32 = 1; + + // Integer/float suffixes + let y: i32 = 13i32; + let f: f64 = 1.3f64; + + // Type inference + // Most of the time, the Rust compiler can infer what type a variable is, so + // you don’t have to write an explicit type annotation. + // Throughout this tutorial, types are explicitly annotated in many places, + // but only for demonstrative purposes. Type inference can handle this for + // you most of the time. + let implicit_x = 1; + let implicit_f = 1.3; + + // Arithmetic + let sum = x + y + 13; + + // Mutable variable + let mut mutable = 1; + mutable = 4; + mutable += 2; + + // Strings // + + // String literals + let x: &str = "hello world!"; + + // Printing + println!("{} {}", f, x); // 1.3 hello world + + // A `String` – a heap-allocated string + let s: String = "hello world".to_string(); + + // A string slice – an immutable view into another string + // This is basically an immutable pointer to a string – it doesn’t + // actually contain the contents of a string, just a pointer to + // something that does (in this case, `s`) + let s_slice: &str = &s; + + println!("{} {}", s, s_slice); // hello world hello world + + // Vectors/arrays // + + // A fixed-size array + let four_ints: [i32; 4] = [1, 2, 3, 4]; + + // A dynamic array (vector) + let mut vector: Vec<i32> = vec![1, 2, 3, 4]; + vector.push(5); + + // A slice – an immutable view into a vector or array + // This is much like a string slice, but for vectors + let slice: &[i32] = &vector; + + // Use `{:?}` to print something debug-style + println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + + // Tuples // + + // A tuple is a fixed-size set of values of possibly different types + let x: (i32, &str, f64) = (1, "hello", 3.4); + + // Destructuring `let` + let (a, b, c) = x; + println!("{} {} {}", a, b, c); // 1 hello 3.4 + + // Indexing + println!("{}", x.1); // hello + + ////////////// + // 2. Types // + ////////////// + + // Struct + struct Point { + x: i32, + y: i32, + } + + let origin: Point = Point { x: 0, y: 0 }; + + // A struct with unnamed fields, called a ‘tuple struct’ + struct Point2(i32, i32); + + let origin2 = Point2(0, 0); + + // Basic C-like enum + enum Direction { + Left, + Right, + Up, + Down, + } + + let up = Direction::Up; + + // Enum with fields + enum OptionalI32 { + AnI32(i32), + Nothing, + } + + let two: OptionalI32 = OptionalI32::AnI32(2); + let nothing = OptionalI32::Nothing; + + // Generics // + + struct Foo<T> { bar: T } + + // This is defined in the standard library as `Option` + enum Optional<T> { + SomeVal(T), + NoVal, + } + + // Methods // + + impl<T> Foo<T> { + // Methods take an explicit `self` parameter + fn get_bar(self) -> T { + self.bar + } + } + + let a_foo = Foo { bar: 1 }; + println!("{}", a_foo.get_bar()); // 1 + + // Traits (known as interfaces or typeclasses in other languages) // + + trait Frobnicate<T> { + fn frobnicate(self) -> Option<T>; + } + + impl<T> Frobnicate<T> for Foo<T> { + fn frobnicate(self) -> Option<T> { + Some(self.bar) + } + } + + let another_foo = Foo { bar: 1 }; + println!("{:?}", another_foo.frobnicate()); // Some(1) + + ///////////////////////// + // 3. Pattern matching // + ///////////////////////// + + let foo = OptionalI32::AnI32(1); + match foo { + OptionalI32::AnI32(n) => println!("it’s an i32: {}", n), + OptionalI32::Nothing => println!("it’s nothing!"), + } + + // Advanced pattern matching + struct FooBar { x: i32, y: OptionalI32 } + let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) }; + + match bar { + FooBar { x: 0, y: OptionalI32::AnI32(0) } => + println!("The numbers are zero!"), + FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m => + println!("The numbers are the same"), + FooBar { x: n, y: OptionalI32::AnI32(m) } => + println!("Different numbers: {} {}", n, m), + FooBar { x: _, y: OptionalI32::Nothing } => + println!("The second number is Nothing!"), + } + + ///////////////////// + // 4. Control flow // + ///////////////////// + + // `for` loops/iteration + let array = [1, 2, 3]; + for i in array.iter() { + println!("{}", i); + } + + // Ranges + for i in 0u32..10 { + print!("{} ", i); + } + println!(""); + // prints `0 1 2 3 4 5 6 7 8 9 ` + + // `if` + if 1 == 1 { + println!("Maths is working!"); + } else { + println!("Oh no..."); + } + + // `if` as expression + let value = if true { + "good" + } else { + "bad" + }; + + // `while` loop + while 1 == 1 { + println!("The universe is operating normally."); + } + + // Infinite loop + loop { + println!("Hello!"); + } + + ///////////////////////////////// + // 5. Memory safety & pointers // + ///////////////////////////////// + + // Owned pointer – only one thing can ‘own’ this pointer at a time + // This means that when the `Box` leaves its scope, it can be automatically deallocated safely. + let mut mine: Box<i32> = Box::new(3); + *mine = 5; // dereference + // Here, `now_its_mine` takes ownership of `mine`. In other words, `mine` is moved. + let mut now_its_mine = mine; + *now_its_mine += 2; + + println!("{}", now_its_mine); // 7 + // println!("{}", mine); // this would not compile because `now_its_mine` now owns the pointer + + // Reference – an immutable pointer that refers to other data + // When a reference is taken to a value, we say that the value has been ‘borrowed’. + // While a value is borrowed immutably, it cannot be mutated or moved. + // A borrow lasts until the end of the scope it was created in. + let mut var = 4; + var = 3; + let ref_var: &i32 = &var; + + println!("{}", var); // Unlike `box`, `var` can still be used + println!("{}", *ref_var); + // var = 5; // this would not compile because `var` is borrowed + // *ref_var = 6; // this would not too, because `ref_var` is an immutable reference + + // Mutable reference + // While a value is mutably borrowed, it cannot be accessed at all. + let mut var2 = 4; + let ref_var2: &mut i32 = &mut var2; + *ref_var2 += 2; + + println!("{}", *ref_var2); // 6 + // var2 = 2; // this would not compile because `var2` is borrowed +} +``` + +## Further reading + +There’s a lot more to Rust—this is just the basics of Rust so you can understand +the most important things. To learn more about Rust, read [The Rust Programming +Language](http://doc.rust-lang.org/book/index.html) and check out the +[/r/rust](http://reddit.com/r/rust) subreddit. The folks on the #rust channel on +irc.mozilla.org are also always keen to help newcomers. + +You can also try out features of Rust with an online compiler at the official +[Rust playpen](http://play.rust-lang.org) or on the main +[Rust website](http://rust-lang.org). diff --git a/scala.html.markdown b/scala.html.markdown new file mode 100644 index 00000000..c482752d --- /dev/null +++ b/scala.html.markdown @@ -0,0 +1,638 @@ +--- +language: Scala +filename: learnscala.scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra", "http://dbousamra.github.com"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Ha-Duong Nguyen", "http://reference-error.org"] +filename: learn.scala +--- + +Scala - the scalable language + +```scala + +/* + Set yourself up: + + 1) Download Scala - http://www.scala-lang.org/downloads + 2) Unzip/untar to your favourite location and put the bin subdir in your `PATH` environment variable + 3) Start a Scala REPL by running `scala`. You should see the prompt: + + scala> + + This is the so called REPL (Read-Eval-Print Loop). You may type any Scala + expression, and the result will be printed. We will explain what Scala files + look like further into this tutorial, but for now, let's start with some + basics. + +*/ + + +///////////////////////////////////////////////// +// 1. Basics +///////////////////////////////////////////////// + +// Single-line comments start with two forward slashes + +/* + Multi-line comments, as you can already see from above, look like this. +*/ + +// Printing, and forcing a new line on the next print +println("Hello world!") +println(10) + +// Printing, without forcing a new line on next print +print("Hello world") + +// Declaring values is done using either var or val. +// val declarations are immutable, whereas vars are mutable. Immutability is +// a good thing. +val x = 10 // x is now 10 +x = 20 // error: reassignment to val +var y = 10 +y = 20 // y is now 20 + +/* + Scala is a statically typed language, yet note that in the above declarations, + we did not specify a type. This is due to a language feature called type + inference. In most cases, Scala compiler can guess what the type of a variable + is, so you don't have to type it every time. We can explicitly declare the + type of a variable like so: +*/ +val z: Int = 10 +val a: Double = 1.0 + +// Notice automatic conversion from Int to Double, result is 10.0, not 10 +val b: Double = 10 + +// Boolean values +true +false + +// Boolean operations +!true // false +!false // true +true == false // false +10 > 5 // true + +// Math is as per usual +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 +6 / 4 // 1 +6.0 / 4 // 1.5 + + +// Evaluating an expression in the REPL gives you the type and value of the result + +1 + 7 + +/* The above line results in: + + scala> 1 + 7 + res29: Int = 8 + + This means the result of evaluating 1 + 7 is an object of type Int with a + value of 8 + + Note that "res29" is a sequentially generated variable name to store the + results of the expressions you typed, your output may differ. +*/ + +"Scala strings are surrounded by double quotes" +'a' // A Scala Char +// 'Single quote strings don't exist' <= This causes an error + +// Strings have the usual Java methods defined on them +"hello world".length +"hello world".substring(2, 6) +"hello world".replace("C", "3") + +// They also have some extra Scala methods. See also: scala.collection.immutable.StringOps +"hello world".take(5) +"hello world".drop(5) + +// String interpolation: notice the prefix "s" +val n = 45 +s"We have $n apples" // => "We have 45 apples" + +// Expressions inside interpolated strings are also possible +val a = Array(11, 9, 6) +s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old." +s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples." +s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" + +// Formatting with interpolated strings with the prefix "f" +f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" +f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" + +// Raw strings, ignoring special characters. +raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." + +// Some characters need to be "escaped", e.g. a double quote inside a string: +"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" + +// Triple double-quotes let strings span multiple rows and contain quotes +val html = """<form id="daform"> + <p>Press belo', Joe</p> + <input type="submit"> + </form>""" + + +///////////////////////////////////////////////// +// 2. Functions +///////////////////////////////////////////////// + +// Functions are defined like so: +// +// def functionName(args...): ReturnType = { body... } +// +// If you come from more traditional languages, notice the omission of the +// return keyword. In Scala, the last expression in the function block is the +// return value. +def sumOfSquares(x: Int, y: Int): Int = { + val x2 = x * x + val y2 = y * y + x2 + y2 +} + +// The { } can be omitted if the function body is a single expression: +def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y + +// Syntax for calling functions is familiar: +sumOfSquares(3, 4) // => 25 + +// In most cases (with recursive functions the most notable exception), function +// return type can be omitted, and the same type inference we saw with variables +// will work with function return values: +def sq(x: Int) = x * x // Compiler can guess return type is Int + +// Functions can have default parameters: +def addWithDefault(x: Int, y: Int = 5) = x + y +addWithDefault(1, 2) // => 3 +addWithDefault(1) // => 6 + + +// Anonymous functions look like this: +(x: Int) => x * x + +// Unlike defs, even the input type of anonymous functions can be omitted if the +// context makes it clear. Notice the type "Int => Int" which means a function +// that takes Int and returns Int. +val sq: Int => Int = x => x * x + +// Anonymous functions can be called as usual: +sq(10) // => 100 + +// If each argument in your anonymous function is +// used only once, Scala gives you an even shorter way to define them. These +// anonymous functions turn out to be extremely common, as will be obvious in +// the data structure section. +val addOne: Int => Int = _ + 1 +val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) + +addOne(5) // => 6 +weirdSum(2, 4) // => 16 + + +// The return keyword exists in Scala, but it only returns from the inner-most +// def that surrounds it. +// WARNING: Using return in Scala is error-prone and should be avoided. +// It has no effect on anonymous functions. For example: +def foo(x: Int): Int = { + val anonFunc: Int => Int = { z => + if (z > 5) + return z // This line makes z the return value of foo! + else + z + 2 // This line is the return value of anonFunc + } + anonFunc(x) // This line is the return value of foo +} + + +///////////////////////////////////////////////// +// 3. Flow Control +///////////////////////////////////////////////// + +1 to 5 +val r = 1 to 5 +r.foreach(println) + +r foreach println +// NB: Scala is quite lenient when it comes to dots and brackets - study the +// rules separately. This helps write DSLs and APIs that read like English + +(5 to 1 by -1) foreach (println) + +// A while loops +var i = 0 +while (i < 10) { println("i " + i); i += 1 } + +while (i < 10) { println("i " + i); i += 1 } // Yes, again. What happened? Why? + +i // Show the value of i. Note that while is a loop in the classical sense - + // it executes sequentially while changing the loop variable. while is very + // fast, faster that Java loops, but using the combinators and + // comprehensions above is easier to understand and parallelize + +// A do while loop +do { + println("x is still less than 10") + x += 1 +} while (x < 10) + +// Tail recursion is an idiomatic way of doing recurring things in Scala. +// Recursive functions need an explicit return type, the compiler can't infer it. +// Here it's Unit. +def showNumbersInRange(a: Int, b: Int): Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} +showNumbersInRange(1, 14) + + +// Conditionals + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + + +///////////////////////////////////////////////// +// 4. Data Structures +///////////////////////////////////////////////// + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // Throws an exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // Throws an exception + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* Look up the documentation of map here - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + * and make sure you can read it + */ + + +// Tuples + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// Why have this? +val divideInts = (x: Int, y: Int) => (x / y, x % y) + +divideInts(10, 3) // The function divideInts gives you the result and the remainder + +// To access the elements of a tuple, use _._n where n is the 1-based index of +// the element +val d = divideInts(10, 3) + +d._1 + +d._2 + + +///////////////////////////////////////////////// +// 5. Object Oriented Programming +///////////////////////////////////////////////// + +/* + Aside: Everything we've done so far in this tutorial has been simple + expressions (values, functions, etc). These expressions are fine to type into + the command-line interpreter for quick tests, but they cannot exist by + themselves in a Scala file. For example, you cannot have just "val x = 5" in + a Scala file. Instead, the only top-level constructs allowed in Scala are: + + - objects + - classes + - case classes + - traits + + And now we will explain what these are. +*/ + +// classes are similar to classes in other languages. Constructor arguments are +// declared after the class name, and initialization is done in the class body. +class Dog(br: String) { + // Constructor code here + var breed: String = br + + // Define a method called bark, returning a String + def bark = "Woof, woof!" + + // Values and methods are assumed public. "protected" and "private" keywords + // are also available. + private def sleep(hours: Int) = + println(s"I'm sleeping for $hours hours") + + // Abstract methods are simply methods with no body. If we uncomment the next + // line, class Dog would need to be declared abstract + // abstract class Dog(...) { ... } + // def chaseAfter(what: String): String +} + +val mydog = new Dog("greyhound") +println(mydog.breed) // => "greyhound" +println(mydog.bark) // => "Woof, woof!" + + +// The "object" keyword creates a type AND a singleton instance of it. It is +// common for Scala classes to have a "companion object", where the per-instance +// behavior is captured in the classes themselves, but behavior related to all +// instance of that class go in objects. The difference is similar to class +// methods vs static methods in other languages. Note that objects and classes +// can have the same name. +object Dog { + def allKnownBreeds = List("pitbull", "shepherd", "retriever") + def createDog(breed: String) = new Dog(breed) +} + + +// Case classes are classes that have extra functionality built in. A common +// question for Scala beginners is when to use classes and when to use case +// classes. The line is quite fuzzy, but in general, classes tend to focus on +// encapsulation, polymorphism, and behavior. The values in these classes tend +// to be private, and only methods are exposed. The primary purpose of case +// classes is to hold immutable data. They often have few methods, and the +// methods rarely have side-effects. +case class Person(name: String, phoneNumber: String) + +// Create a new instance. Note cases classes don't need "new" +val george = Person("George", "1234") +val kate = Person("Kate", "4567") + +// With case classes, you get a few perks for free, like getters: +george.phoneNumber // => "1234" + +// Per field equality (no need to override .equals) +Person("George", "1234") == Person("Kate", "1236") // => false + +// Easy way to copy +// otherGeorge == Person("george", "9876") +val otherGeorge = george.copy(phoneNumber = "9876") + +// And many others. Case classes also get pattern matching for free, see below. + + +// Traits coming soon! + + +///////////////////////////////////////////////// +// 6. Pattern Matching +///////////////////////////////////////////////// + +// Pattern matching is a powerful and commonly used feature in Scala. Here's how +// you pattern match a case class. NB: Unlike other languages, Scala cases do +// not need breaks, fall-through does not happen. + +def matchPerson(person: Person): String = person match { + // Then you specify the patterns: + case Person("George", number) => "We found George! His number is " + number + case Person("Kate", number) => "We found Kate! Her number is " + number + case Person(name, number) => "We matched someone : " + name + ", phone : " + number +} + +val email = "(.*)@(.*)".r // Define a regex for the next example. + +// Pattern matching might look familiar to the switch statements in the C family +// of languages, but this is much more powerful. In Scala, you can match much +// more: +def matchEverything(obj: Any): String = obj match { + // You can match values: + case "Hello world" => "Got the string Hello world" + + // You can match by type: + case x: Double => "Got a Double: " + x + + // You can specify conditions: + case x: Int if x > 10000 => "Got a pretty big number!" + + // You can match case classes as before: + case Person(name, number) => s"Got contact info for $name!" + + // You can match regular expressions: + case email(name, domain) => s"Got email address $name@$domain" + + // You can match tuples: + case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" + + // You can match data structures: + case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" + + // You can nest patterns: + case List(List((1, 2, "YAY"))) => "Got a list of list of tuple" +} + +// In fact, you can pattern match any object with an "unapply" method. This +// feature is so powerful that Scala lets you define whole functions as +// patterns: +val patternFunc: Person => String = { + case Person("George", number) => s"George's number: $number" + case Person(name, number) => s"Random person's number: $number" +} + + +///////////////////////////////////////////////// +// 7. Functional Programming +///////////////////////////////////////////////// + +// Scala allows methods and functions to return, or take as parameters, other +// functions or methods. + +val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int +List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element + +// Anonymous functions can be used instead of named functions: +List(1, 2, 3) map (x => x + 10) + +// And the underscore symbol, can be used if there is just one argument to the +// anonymous function. It gets bound as the variable +List(1, 2, 3) map (_ + 10) + +// If the anonymous block AND the function you are applying both take one +// argument, you can even omit the underscore +List("Dom", "Bob", "Natalia") foreach println + + +// Combinators + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + +// The filter function takes a predicate (a function from A -> Boolean) and +// selects all elements which satisfy the predicate +List(1, 2, 3) filter (_ > 2) // List(3) +case class Person(name: String, age: Int) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + + +// Scala a foreach method defined on certain collections that takes a type +// returning Unit (a void method) +val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + +// For comprehensions + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + +/* NB Those were not for loops. The semantics of a for loop is 'repeat', whereas + a for-comprehension defines a relationship between two sets of data. */ + + +///////////////////////////////////////////////// +// 8. Implicits +///////////////////////////////////////////////// + +/* WARNING WARNING: Implicits are a set of powerful features of Scala, and + * therefore it is easy to abuse them. Beginners to Scala should resist the + * temptation to use them until they understand not only how they work, but also + * best practices around them. We only include this section in the tutorial + * because they are so commonplace in Scala libraries that it is impossible to + * do anything meaningful without using a library that has implicits. This is + * meant for you to understand and work with implicts, not declare your own. + */ + +// Any value (vals, functions, objects, etc) can be declared to be implicit by +// using the, you guessed it, "implicit" keyword. Note we are using the Dog +// class from section 5 in these examples. +implicit val myImplicitInt = 100 +implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed) + +// By itself, implicit keyword doesn't change the behavior of the value, so +// above values can be used as usual. +myImplicitInt + 2 // => 102 +myImplicitFunction("Pitbull").breed // => "Golden Pitbull" + +// The difference is that these values are now eligible to be used when another +// piece of code "needs" an implicit value. One such situation is implicit +// function arguments: +def sendGreetings(toWhom: String)(implicit howMany: Int) = + s"Hello $toWhom, $howMany blessings to you and yours!" + +// If we supply a value for "howMany", the function behaves as usual +sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" + +// But if we omit the implicit parameter, an implicit value of the same type is +// used, in this case, "myImplicitInt": +sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" + +// Implicit function parameters enable us to simulate type classes in other +// functional languages. It is so often used that it gets its own shorthand. The +// following two lines mean the same thing: +def foo[T](implicit c: C[T]) = ... +def foo[T : C] = ... + + +// Another situation in which the compiler looks for an implicit is if you have +// obj.method(...) +// but "obj" doesn't have "method" as a method. In this case, if there is an +// implicit conversion of type A => B, where A is the type of obj, and B has a +// method called "method", that conversion is applied. So having +// myImplicitFunction above in scope, we can say: +"Retriever".breed // => "Golden Retriever" +"Sheperd".bark // => "Woof, woof!" + +// Here the String is first converted to Dog using our function above, and then +// the appropriate method is called. This is an extremely powerful feature, but +// again, it is not to be used lightly. In fact, when you defined the implicit +// function above, your compiler should have given you a warning, that you +// shouldn't do this unless you really know what you're doing. + + +///////////////////////////////////////////////// +// 9. Misc +///////////////////////////////////////////////// + +// Importing things +import scala.collection.immutable.List + +// Import all "sub packages" +import scala.collection.immutable._ + +// Import multiple classes in one statement +import scala.collection.immutable.{List, Map} + +// Rename an import using '=>' +import scala.collection.immutable.{List => ImmutableList} + +// Import all classes, except some. The following excludes Map and Set: +import scala.collection.immutable.{Map => _, Set => _, _} + +// Your programs entry point is defined in an scala file using an object, with a +// single method, main: +object Application { + def main(args: Array[String]): Unit = { + // stuff goes here. + } +} + +// Files can contain multiple classes and objects. Compile with scalac + + + + +// Input and output + +// To read a file line by line +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// To write a file use Java's PrintWriter +val writer = new PrintWriter("myfile.txt") +writer.write("Writing line for line" + util.Properties.lineSeparator) +writer.write("Another line here" + util.Properties.lineSeparator) +writer.close() + +``` + +## Further resources + +* [Scala for the impatient](http://horstmann.com/scala/) +* [Twitter Scala school](http://twitter.github.io/scala_school/) +* [The scala documentation](http://docs.scala-lang.org/) +* [Try Scala in your browser](http://scalatutorials.com/tour/) +* Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user) diff --git a/self.html.markdown b/self.html.markdown new file mode 100644 index 00000000..9290a0c9 --- /dev/null +++ b/self.html.markdown @@ -0,0 +1,161 @@ +--- +language: self +contributors: + - ["Russell Allen", "http://github.com/russellallen"] +filename: learnself.self +--- + +Self is a fast prototype based OO language which runs in its own JIT vm. Most development is done through interacting with live objects through a visual development environment called *morphic* with integrated browsers and debugger. + +Everything in Self is an object. All computation is done by sending messages to objects. Objects in Self can be understood as sets of key-value slots. + +# Constructing objects + +The inbuild Self parser can construct objects, including method objects. + +``` +"This is a comment" + +"A string:" +'This is a string with \'escaped\' characters.\n' + +"A 30 bit integer" +23 + +"A 30 bit float" +3.2 + +"-20" +-14r16 + +"An object which only understands one message, 'x' which returns 20" +(| + x = 20. +|) + +"An object which also understands 'x:' which sets the x slot" +(| + x <- 20. +|) + +"An object which understands the method 'doubleX' which +doubles the value of x and then returns the object" +(| + x <- 20. + doubleX = (x: x * 2. self) +|) + +"An object which understands all the messages +that 'traits point' understands". The parser +looks up 'traits point' by sending the messages +'traits' then 'point' to a known object called +the 'lobby'. It looks up the 'true' object by +also sending the message 'true' to the lobby." +(| parent* = traits point. + x = 7. + y <- 5. + isNice = true. +|) +``` + +# Sending messages to objects + +Messages can either be unary, binary or keyword. Precedence is in that order. Unlike Smalltalk, the precedence of binary messages must be specified, and all keywords after the first must start with a capital letter. Messages are separeated from their destination by whitespace. + +``` +"unary message, sends 'printLine' to the object '23' +which prints the string '23' to stdout and returns the receiving object (ie 23)" +23 printLine + +"sends the message '+' with '7' to '23', then the message '*' with '8' to the result" +(23 + 7) * 8 + +"sends 'power:' to '2' with '8' returns 256" +2 power: 8 + +"sends 'keyOf:IfAbsent:' to 'hello' with arguments 'e' and '-1'. +Returns 1, the index of 'e' in 'hello'." +'hello' keyOf: 'e' IfAbsent: -1 +``` + +# Blocks + +Self defines flow control like Smalltalk and Ruby by way of blocks. Blocks are delayed computations of the form: + +``` +[|:x. localVar| x doSomething with: localVar] +``` + +Examples of the use of a block: + +``` +"returns 'HELLO'" +'hello' copyMutable mapBy: [|:c| c capitalize] + +"returns 'Nah'" +'hello' size > 5 ifTrue: ['Yay'] False: ['Nah'] + +"returns 'HaLLO'" +'hello' copyMutable mapBy: [|:c| + c = 'e' ifTrue: [c capitalize] + False: ['a']] +``` + +Multiple expressions are separated by a period. ^ returns immediately. + +``` +"returns An 'E'! How icky!" +'hello' copyMutable mapBy: [|:c. tmp <- ''| + tmp: c capitalize. + tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!']. + c capitalize + ] +``` + +Blocks are performed by sending them the message 'value' and inherit (delegate to) their contexts: +``` +"returns 0" +[|x| + x: 15. + "Repeatedly sends 'value' to the first block while the result of sending 'value' to the + second block is the 'true' object" + [x > 0] whileTrue: [x: x - 1]. + x +] value +``` + +# Methods + +Methods are like blocks but they are not within a context but instead are stored as values of slots. Unlike Smalltalk, methods by default return their final value not 'self'. + +``` +"Here is an object with one assignable slot 'x' and a method 'reduceXTo: y'. +Sending the message 'reduceXTo: 10' to this object will put +the object '10' in the 'x' slot and return the original object" +(| + x <- 50. + reduceXTo: y = ( + [x > y] whileTrue: [x: x - 1]. + self) +|) +. +``` + +# Prototypes + +Self has no classes. The way to get an object is to find a prototype and copy it. + +``` +| d | +d: dictionary copy. +d at: 'hello' Put: 23 + 8. +d at: 'goodbye' Put: 'No!. +"Prints No!" +( d at: 'goodbye' IfAbsent: 'Yes! ) printLine. +"Prints 31" +( d at: 'hello' IfAbsent: -1 ) printLine. +``` + +# Further information + +The [Self handbook](http://handbook.selflanguage.org) has much more information, and nothing beats hand-on experience with Self by downloading it from the [homepage](http://www.selflanguage.org). diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown new file mode 100644 index 00000000..3b388505 --- /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/standard-ml.html.markdown b/standard-ml.html.markdown new file mode 100644 index 00000000..143980e7 --- /dev/null +++ b/standard-ml.html.markdown @@ -0,0 +1,446 @@ +--- +language: "Standard ML" +contributors: + - ["Simon Shine", "http://shine.eu.org/"] + - ["David Pedersen", "http://lonelyproton.com/"] + - ["James Baker", "http://www.jbaker.io/"] + - ["Leo Zovic", "http://langnostic.inaimathi.ca/"] +--- + +Standard ML is a functional programming language with type inference and some +side-effects. Some of the hard parts of learning Standard ML are: Recursion, +pattern matching, type inference (guessing the right types but never allowing +implicit type conversion). Standard ML is distinguished from Haskell by including +references, allowing variables to be updated. + +```ocaml +(* Comments in Standard ML begin with (* and end with *). Comments can be + nested which means that all (* tags must end with a *) tag. This comment, + for example, contains two nested comments. *) + +(* A Standard ML program consists of declarations, e.g. value declarations: *) +val rent = 1200 +val phone_no = 5551337 +val pi = 3.14159 +val negative_number = ~15 (* Yeah, unary minus uses the 'tilde' symbol *) + +(* And just as importantly, functions: *) +fun is_large(x : int) = if x > 37 then true else false + +(* Floating-point numbers are called "reals". *) +val tau = 2.0 * pi (* You can multiply two reals *) +val twice_rent = 2 * rent (* You can multiply two ints *) +(* val meh = 1.25 * 10 *) (* But you can't multiply an int and a real *) + +(* +, - and * are overloaded so they work for both int and real. *) +(* The same cannot be said for division which has separate operators: *) +val real_division = 14.0 / 4.0 (* gives 3.5 *) +val int_division = 14 div 4 (* gives 3, rounding down *) +val int_remainder = 14 mod 4 (* gives 2, since 3*4 = 12 *) + +(* ~ is actually sometimes a function (e.g. when put in front of variables) *) +val negative_rent = ~(rent) (* Would also have worked if rent were a "real" *) + +(* There are also booleans and boolean operators *) +val got_milk = true +val got_bread = false +val has_breakfast = got_milk andalso got_bread (* 'andalso' is the operator *) +val has_something = got_milk orelse got_bread (* 'orelse' is the operator *) +val is_sad = not(has_something) (* not is a function *) + +(* Many values can be compared using equality operators: = and <> *) +val pays_same_rent = (rent = 1300) (* false *) +val is_wrong_phone_no = (phone_no <> 5551337) (* false *) + +(* The operator <> is what most other languages call !=. *) +(* 'andalso' and 'orelse' are called && and || in many other languages. *) + +(* Actually, most of the parentheses above are unnecessary. Here are some + different ways to say some of the things mentioned above: *) +fun is_large x = x > 37 (* The parens above were necessary because of ': int' *) +val is_sad = not has_something +val pays_same_rent = rent = 1300 (* Looks confusing, but works *) +val is_wrong_phone_no = phone_no <> 5551337 +val negative_rent = ~rent (* ~ rent (notice the space) would also work *) + +(* Parentheses are mostly necessary when grouping things: *) +val some_answer = is_large (5 + 5) (* Without parens, this would break! *) +(* val some_answer = is_large 5 + 5 *) (* Read as: (is_large 5) + 5. Bad! *) + + +(* Besides booleans, ints and reals, Standard ML also has chars and strings: *) +val foo = "Hello, World!\n" (* The \n is the escape sequence for linebreaks *) +val one_letter = #"a" (* That funky syntax is just one character, a *) + +val combined = "Hello " ^ "there, " ^ "fellow!\n" (* Concatenate strings *) + +val _ = print foo (* You can print things. We are not interested in the *) +val _ = print combined (* result of this computation, so we throw it away. *) +(* val _ = print one_letter *) (* Only strings can be printed this way *) + + +val bar = [ #"H", #"e", #"l", #"l", #"o" ] (* SML also has lists! *) +(* val _ = print bar *) (* Lists are unfortunately not the same as strings *) + +(* Fortunately they can be converted. String is a library and implode and size + are functions available in that library that take strings as argument. *) +val bob = String.implode bar (* gives "Hello" *) +val bob_char_count = String.size bob (* gives 5 *) +val _ = print (bob ^ "\n") (* For good measure, add a linebreak *) + +(* You can have lists of any kind *) +val numbers = [1, 3, 3, 7, 229, 230, 248] (* : int list *) +val names = [ "Fred", "Jane", "Alice" ] (* : string list *) + +(* Even lists of lists of things *) +val groups = [ [ "Alice", "Bob" ], + [ "Huey", "Dewey", "Louie" ], + [ "Bonnie", "Clyde" ] ] (* : string list list *) + +val number_count = List.length numbers (* gives 7 *) + +(* You can put single values in front of lists of the same kind using + the :: operator, called "the cons operator" (known from Lisp). *) +val more_numbers = 13 :: numbers (* gives [13, 1, 3, 3, 7, ...] *) +val more_groups = ["Batman","Superman"] :: groups + +(* Lists of the same kind can be appended using the @ ("append") operator *) +val guest_list = [ "Mom", "Dad" ] @ [ "Aunt", "Uncle" ] + +(* This could have been done with the "cons" operator. It is tricky because the + left-hand-side must be an element whereas the right-hand-side must be a list + of those elements. *) +val guest_list = "Mom" :: "Dad" :: [ "Aunt", "Uncle" ] +val guest_list = "Mom" :: ("Dad" :: ("Aunt" :: ("Uncle" :: []))) + +(* If you have many lists of the same kind, you can concatenate them all *) +val everyone = List.concat groups (* [ "Alice", "Bob", "Huey", ... ] *) + +(* A list can contain any (finite) number of values *) +val lots = [ 5, 5, 5, 6, 4, 5, 6, 5, 4, 5, 7, 3 ] (* still just an int list *) + +(* Lists can only contain one kind of thing... *) +(* val bad_list = [ 1, "Hello", 3.14159 ] : ??? list *) + + +(* Tuples, on the other hand, can contain a fixed number of different things *) +val person1 = ("Simon", 28, 3.14159) (* : string * int * real *) + +(* You can even have tuples inside lists and lists inside tuples *) +val likes = [ ("Alice", "ice cream"), + ("Bob", "hot dogs"), + ("Bob", "Alice") ] (* : (string * string) list *) + +val mixup = [ ("Alice", 39), + ("Bob", 37), + ("Eve", 41) ] (* : (string * int) list *) + +val good_bad_stuff = + (["ice cream", "hot dogs", "chocolate"], + ["liver", "paying the rent" ]) (* : string list * string list *) + + +(* Records are tuples with named slots *) + +val rgb = { r=0.23, g=0.56, b=0.91 } (* : {b:real, g:real, r:real} *) + +(* You don't need to declare their slots ahead of time. Records with + different slot names are considered different types, even if their + slot value types match up. For instance... *) + +val Hsl = { H=310.3, s=0.51, l=0.23 } (* : {H:real, l:real, s:real} *) +val Hsv = { H=310.3, s=0.51, v=0.23 } (* : {H:real, s:real, v:real} *) + +(* ...trying to evaluate `Hsv = Hsl` or `rgb = Hsl` would give a type + error. While they're all three-slot records composed only of `real`s, + they each have different names for at least some slots. *) + +(* You can use hash notation to get values out of tuples. *) + +val H = #H Hsv (* : real *) +val s = #s Hsl (* : real *) + +(* Functions! *) +fun add_them (a, b) = a + b (* A simple function that adds two numbers *) +val test_it = add_them (3, 4) (* gives 7 *) + +(* Larger functions are usually broken into several lines for readability *) +fun thermometer temp = + if temp < 37 + then "Cold" + else if temp > 37 + then "Warm" + else "Normal" + +val test_thermo = thermometer 40 (* gives "Warm" *) + +(* if-sentences are actually expressions and not statements/declarations. + A function body can only contain one expression. There are some tricks + for making a function do more than just one thing, though. *) + +(* A function can call itself as part of its result (recursion!) *) +fun fibonacci n = + if n = 0 then 0 else (* Base case *) + if n = 1 then 1 else (* Base case *) + fibonacci (n - 1) + fibonacci (n - 2) (* Recursive case *) + +(* Sometimes recursion is best understood by evaluating a function by hand: + + fibonacci 4 + ~> fibonacci (4 - 1) + fibonacci (4 - 2) + ~> fibonacci 3 + fibonacci 2 + ~> (fibonacci (3 - 1) + fibonacci (3 - 2)) + fibonacci 2 + ~> (fibonacci 2 + fibonacci 1) + fibonacci 2 + ~> ((fibonacci (2 - 1) + fibonacci (2 - 2)) + fibonacci 1) + fibonacci 2 + ~> ((fibonacci 1 + fibonacci 0) + fibonacci 1) + fibonacci 2 + ~> ((1 + fibonacci 0) + fibonacci 1) + fibonacci 2 + ~> ((1 + 0) + fibonacci 1) + fibonacci 2 + ~> (1 + fibonacci 1) + fibonacci 2 + ~> (1 + 1) + fibonacci 2 + ~> 2 + fibonacci 2 + ~> 2 + (fibonacci (2 - 1) + fibonacci (2 - 2)) + ~> 2 + (fibonacci (2 - 1) + fibonacci (2 - 2)) + ~> 2 + (fibonacci 1 + fibonacci 0) + ~> 2 + (1 + fibonacci 0) + ~> 2 + (1 + 0) + ~> 2 + 1 + ~> 3 which is the 4th Fibonacci number, according to this definition + + *) + +(* A function cannot change the variables it can refer to. It can only + temporarily shadow them with new variables that have the same names. In this + sense, variables are really constants and only behave like variables when + dealing with recursion. For this reason, variables are also called value + bindings. An example of this: *) + +val x = 42 +fun answer(question) = + if question = "What is the meaning of life, the universe and everything?" + then x + else raise Fail "I'm an exception. Also, I don't know what the answer is." +val x = 43 +val hmm = answer "What is the meaning of life, the universe and everything?" +(* Now, hmm has the value 42. This is because the function answer refers to + the copy of x that was visible before its own function definition. *) + + +(* Functions can take several arguments by taking one tuples as argument: *) +fun solve2 (a : real, b : real, c : real) = + ( (~b + Math.sqrt(b * b - 4.0*a*c)) / (2.0 * a), + (~b - Math.sqrt(b * b - 4.0*a*c)) / (2.0 * a) ) + +(* Sometimes, the same computation is carried out several times. It makes sense + to save and re-use the result the first time. We can use "let-bindings": *) +fun solve2 (a : real, b : real, c : real) = + let val discr = b * b - 4.0*a*c + val sqr = Math.sqrt discr + val denom = 2.0 * a + in ((~b + sqr) / denom, + (~b - sqr) / denom) end + + +(* Pattern matching is a funky part of functional programming. It is an + alternative to if-sentences. The fibonacci function can be rewritten: *) +fun fibonacci 0 = 0 (* Base case *) + | fibonacci 1 = 1 (* Base case *) + | fibonacci n = fibonacci (n - 1) + fibonacci (n - 2) (* Recursive case *) + +(* Pattern matching is also possible on composite types like tuples, lists and + records. Writing "fun solve2 (a, b, c) = ..." is in fact a pattern match on + the one three-tuple solve2 takes as argument. Similarly, but less intuitively, + you can match on a list consisting of elements in it (from the beginning of + the list only). *) +fun first_elem (x::xs) = x +fun second_elem (x::y::xs) = y +fun evenly_positioned_elems (odd::even::xs) = even::evenly_positioned_elems xs + | evenly_positioned_elems [odd] = [] (* Base case: throw away *) + | evenly_positioned_elems [] = [] (* Base case *) + +(* When matching on records, you must use their slot names, and you must bind + every slot in a record. The order of the slots doesn't matter though. *) + +fun rgbToTup {r, g, b} = (r, g, b) (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *) +fun mixRgbToTup {g, b, r} = (r, g, b) (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *) + +(* If called with {r=0.1, g=0.2, b=0.3}, either of the above functions + would return (0.1, 0.2, 0.3). But it would be a type error to call them + with {r=0.1, g=0.2, b=0.3, a=0.4} *) + +(* Higher order functions: Functions can take other functions as arguments. + Functions are just other kinds of values, and functions don't need names + to exist. Functions without names are called "anonymous functions" or + lambda expressions or closures (since they also have a lexical scope). *) +val is_large = (fn x => x > 37) +val add_them = fn (a,b) => a + b +val thermometer = + fn temp => if temp < 37 + then "Cold" + else if temp > 37 + then "Warm" + else "Normal" + +(* The following uses an anonymous function directly and gives "ColdWarm" *) +val some_result = (fn x => thermometer (x - 5) ^ thermometer (x + 5)) 37 + +(* Here is a higher-order function that works on lists (a list combinator) *) +val readings = [ 34, 39, 37, 38, 35, 36, 37, 37, 37 ] (* first an int list *) +val opinions = List.map thermometer readings (* gives [ "Cold", "Warm", ... ] *) + +(* And here is another one for filtering lists *) +val warm_readings = List.filter is_large readings (* gives [39, 38] *) + +(* You can create your own higher-order functions, too. Functions can also take + several arguments by "currying" them. Syntax-wise this means adding spaces + between function arguments instead of commas and surrounding parentheses. *) +fun map f [] = [] + | map f (x::xs) = f(x) :: map f xs + +(* map has type ('a -> 'b) -> 'a list -> 'b list and is called polymorphic. *) +(* 'a is called a type variable. *) + + +(* We can declare functions as infix *) +val plus = add_them (* plus is now equal to the same function as add_them *) +infix plus (* plus is now an infix operator *) +val seven = 2 plus 5 (* seven is now bound to 7 *) + +(* Functions can also be made infix before they are declared *) +infix minus +fun x minus y = x - y (* It becomes a little hard to see what's the argument *) +val four = 8 minus 4 (* four is now bound to 4 *) + +(* An infix function/operator can be made prefix with 'op' *) +val n = op + (5, 5) (* n is now 10 *) + +(* 'op' is useful when combined with high order functions because they expect + functions and not operators as arguments. Most operators are really just + infix functions. *) +val sum_of_numbers = foldl op+ 0 [1,2,3,4,5] + + +(* Datatypes are useful for creating both simple and complex structures *) +datatype color = Red | Green | Blue + +(* Here is a function that takes one of these as argument *) +fun say(col) = + if col = Red then "You are red!" else + if col = Green then "You are green!" else + if col = Blue then "You are blue!" else + raise Fail "Unknown color" + +val _ = print (say(Red) ^ "\n") + +(* Datatypes are very often used in combination with pattern matching *) +fun say Red = "You are red!" + | say Green = "You are green!" + | say Blue = "You are blue!" + | say _ = raise Fail "Unknown color" + + +(* Here is a binary tree datatype *) +datatype 'a btree = Leaf of 'a + | Node of 'a btree * 'a * 'a btree (* three-arg constructor *) + +(* Here is a binary tree *) +val myTree = Node (Leaf 9, 8, Node (Leaf 3, 5, Leaf 7)) + +(* Drawing it, it might look something like... + + 8 + / \ + leaf -> 9 5 + / \ + leaf -> 3 7 <- leaf + *) + +(* This function counts the sum of all the elements in a tree *) +fun count (Leaf n) = n + | count (Node (leftTree, n, rightTree)) = count leftTree + n + count rightTree + +val myTreeCount = count myTree (* myTreeCount is now bound to 32 *) + + +(* Exceptions! *) +(* Exceptions can be raised/thrown using the reserved word 'raise' *) +fun calculate_interest(n) = if n < 0.0 + then raise Domain + else n * 1.04 + +(* Exceptions can be caught using "handle" *) +val balance = calculate_interest ~180.0 + handle Domain => ~180.0 (* x now has the value ~180.0 *) + +(* Some exceptions carry extra information with them *) +(* Here are some examples of built-in exceptions *) +fun failing_function [] = raise Empty (* used for empty lists *) + | failing_function [x] = raise Fail "This list is too short!" + | failing_function [x,y] = raise Overflow (* used for arithmetic *) + | failing_function xs = raise Fail "This list is too long!" + +(* We can pattern match in 'handle' to make sure + a specfic exception was raised, or grab the message *) +val err_msg = failing_function [1,2] handle Fail _ => "Fail was raised" + | Domain => "Domain was raised" + | Empty => "Empty was raised" + | _ => "Unknown exception" + +(* err_msg now has the value "Unknown exception" because Overflow isn't + listed as one of the patterns -- thus, the catch-all pattern _ is used. *) + +(* We can define our own exceptions like this *) +exception MyException +exception MyExceptionWithMessage of string +exception SyntaxError of string * (int * int) + +(* File I/O! *) +(* Write a nice poem to a file *) +fun writePoem(filename) = + let val file = TextIO.openOut(filename) + val _ = TextIO.output(file, "Roses are red,\nViolets are blue.\n") + val _ = TextIO.output(file, "I have a gun.\nGet in the van.\n") + in TextIO.closeOut(file) end + +(* Read a nice poem from a file into a list of strings *) +fun readPoem(filename) = + let val file = TextIO.openIn filename + val poem = TextIO.inputAll file + val _ = TextIO.closeIn file + in String.tokens (fn c => c = #"\n") poem + end + +val _ = writePoem "roses.txt" +val test_poem = readPoem "roses.txt" (* gives [ "Roses are red,", + "Violets are blue.", + "I have a gun.", + "Get in the van." ] *) + +(* We can create references to data which can be updated *) +val counter = ref 0 (* Produce a reference with the ref function *) + +(* Assign to a reference with the assignment operator *) +fun set_five reference = reference := 5 + +(* Read a reference with the dereference operator *) +fun equals_five reference = !reference = 5 + +(* We can use while loops for when recursion is messy *) +fun decrement_to_zero r = if !r < 0 + then r := 0 + else while !r >= 0 do r := !r - 1 + +(* This returns the unit value (in practical terms, nothing, a 0-tuple) *) + +(* To allow returning a value, we can use the semicolon to sequence evaluations *) +fun decrement_ret x y = (x := !x - 1; y) +``` + +## Further learning + +* Install an interactive compiler (REPL), for example + [Poly/ML](http://www.polyml.org/), + [Moscow ML](http://mosml.org), + [SML/NJ](http://smlnj.org/). +* Follow the Coursera course [Programming Languages](https://www.coursera.org/course/proglang). +* Get the book *ML for the Working Programmer* by Larry C. Paulson. +* Use [StackOverflow's sml tag](http://stackoverflow.com/questions/tagged/sml). diff --git a/swift.html.markdown b/swift.html.markdown new file mode 100644 index 00000000..a40e86c8 --- /dev/null +++ b/swift.html.markdown @@ -0,0 +1,577 @@ +--- +language: swift +contributors: + - ["Grant Timmerman", "http://github.com/grant"] + - ["Christopher Bess", "http://github.com/cbess"] + - ["Joey Huang", "http://github.com/kamidox"] + - ["Anthony Nguyen", "http://github.com/anthonyn60"] +filename: learnswift.swift +--- + +Swift is a programming language for iOS and OS X development created by Apple. Designed to coexist with Objective-C and to be more resilient against erroneous code, Swift was introduced in 2014 at Apple's developer conference WWDC. It is built with the LLVM compiler included in Xcode 6+. + +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/DevelopiOSAppsSwift/), which has a complete tutorial on Swift. + +```swift +// import a module +import UIKit + +// +// MARK: Basics +// + +// Xcode supports landmarks to annotate your code and lists them in the jump bar +// MARK: Section mark +// TODO: Do something soon +// FIXME: Fix this code + +// In Swift 2, println and print were combined into one print method. Print automatically appends a new line. +print("Hello, world") // println is now print +print("Hello, world", appendNewLine: false) // printing without appending a newline + +// variables (var) value can change after being set +// constants (let) value can NOT be changed after being set + +var myVariable = 42 +let øπΩ = "value" // unicode variable names +let π = 3.1415926 +let convenience = "keyword" // contextual variable name +let weak = "keyword"; let override = "another keyword" // statements can be separated by a semi-colon +let `class` = "keyword" // backticks allow keywords to be used as variable names +let explicitDouble: Double = 70 +let intValue = 0007 // 7 +let largeIntValue = 77_000 // 77000 +let label = "some text " + String(myVariable) // Casting +let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String interpolation + +// Build Specific values +// uses -D build configuration +#if false + print("Not printed") + let buildValue = 3 +#else + let buildValue = 7 +#endif +print("Build value: \(buildValue)") // Build value: 7 + +/* + Optionals are a Swift language feature that allows you to store a `Some` or + `None` value. + + Because Swift requires every property to have a value, even nil must be + explicitly stored as an Optional value. + + Optional<T> is an enum. +*/ +var someOptionalString: String? = "optional" // Can be nil +// same as above, but ? is a postfix operator (syntax candy) +var someOptionalString2: Optional<String> = "optional" + +if someOptionalString != nil { + // I am not nil + if someOptionalString!.hasPrefix("opt") { + print("has the prefix") + } + + let empty = someOptionalString?.isEmpty +} +someOptionalString = nil + +// implicitly unwrapped optional +var unwrappedString: String! = "Value is expected." +// same as above, but ! is a postfix operator (more syntax candy) +var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected." + +if let someOptionalStringConstant = someOptionalString { + // has `Some` value, non-nil + if !someOptionalStringConstant.hasPrefix("ok") { + // does not have the prefix + } +} + +// Swift has support for storing a value of any type. +// AnyObject == id +// Unlike Objective-C `id`, AnyObject works with any value (Class, Int, struct, etc) +var anyObjectVar: AnyObject = 7 +anyObjectVar = "Changed value to a string, not good practice, but possible." + +/* + Comment here + + /* + Nested comments are also supported + */ +*/ + +// +// MARK: Collections +// + +/* + Array and Dictionary types are structs. So `let` and `var` also indicate + that they are mutable (var) or immutable (let) when declaring these types. +*/ + +// Array +var shoppingList = ["catfish", "water", "lemons"] +shoppingList[1] = "bottle of water" +let emptyArray = [String]() // let == immutable +let emptyArray2 = Array<String>() // same as above +var emptyMutableArray = [String]() // var == mutable + + +// Dictionary +var occupations = [ + "Malcolm": "Captain", + "kaylee": "Mechanic" +] +occupations["Jayne"] = "Public Relations" +let emptyDictionary = [String: Float]() // let == immutable +let emptyDictionary2 = Dictionary<String, Float>() // same as above +var emptyMutableDictionary = [String: Float]() // var == mutable + + +// +// MARK: Control Flow +// + +// for loop (array) +let myArray = [1, 1, 2, 3, 5] +for value in myArray { + if value == 1 { + print("One!") + } else { + print("Not one!") + } +} + +// for loop (dictionary) +var dict = ["one": 1, "two": 2] +for (key, value) in dict { + print("\(key): \(value)") +} + +// for loop (range) +for i in -1...shoppingList.count { + print(i) +} +shoppingList[1...2] = ["steak", "peacons"] +// use ..< to exclude the last number + +// while loop +var i = 1 +while i < 1000 { + i *= 2 +} + +// do-while loop +do { + print("hello") +} while 1 == 2 + +// Switch +// Very powerful, think `if` statements with syntax candy +// They support String, object instances, and primitives (Int, Double, etc) +let vegetable = "red pepper" +switch vegetable { +case "celery": + let vegetableComment = "Add some raisins and make ants on a log." +case "cucumber", "watercress": + let vegetableComment = "That would make a good tea sandwich." +case let localScopeValue where localScopeValue.hasSuffix("pepper"): + let vegetableComment = "Is it a spicy \(localScopeValue)?" +default: // required (in order to cover all possible input) + let vegetableComment = "Everything tastes good in soup." +} + + +// +// MARK: Functions +// + +// Functions are a first-class type, meaning they can be nested +// in functions and can be passed around + +// Function with Swift header docs (format as reStructedText) + +/** + A greet operation + + - A bullet in docs + - Another bullet in the docs + + :param: name A name + :param: day A day + :returns: A string containing the name and day value. +*/ +func greet(name: String, day: String) -> String { + return "Hello \(name), today is \(day)." +} +greet("Bob", "Tuesday") + +// similar to above except for the function parameter behaviors +func greet2(#requiredName: String, externalParamName localParamName: String) -> String { + return "Hello \(requiredName), the day is \(localParamName)" +} +greet2(requiredName:"John", externalParamName: "Sunday") + +// Function that returns multiple items in a tuple +func getGasPrices() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let pricesTuple = getGasPrices() +let price = pricesTuple.2 // 3.79 +// Ignore Tuple (or other) values by using _ (underscore) +let (_, price1, _) = pricesTuple // price1 == 3.69 +print(price1 == pricesTuple.1) // true +print("Gas price: \(price)") + +// Variadic Args +func setup(numbers: Int...) { + // its an array + let number = numbers[0] + let argCount = numbers.count +} + +// Passing and returning functions +func makeIncrementer() -> (Int -> Int) { + func addOne(number: Int) -> Int { + return 1 + number + } + return addOne +} +var increment = makeIncrementer() +increment(7) + +// pass by ref +func swapTwoInts(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +swapTwoInts(&someIntA, &someIntB) +print(someIntB) // 7 + + +// +// MARK: Closures +// +var numbers = [1, 2, 6] + +// Functions are special case closures ({}) + +// Closure example. +// `->` separates the arguments and return type +// `in` separates the closure header from the closure body +numbers.map({ + (number: Int) -> Int in + let result = 3 * number + return result +}) + +// When the type is known, like above, we can do this +numbers = numbers.map({ number in 3 * number }) +// Or even this +//numbers = numbers.map({ $0 * 3 }) + +print(numbers) // [3, 6, 18] + +// Trailing closure +numbers = sorted(numbers) { $0 > $1 } + +print(numbers) // [18, 6, 3] + +// Super shorthand, since the < operator infers the types + +numbers = sorted(numbers, < ) + +print(numbers) // [3, 6, 18] + +// +// MARK: Structures +// + +// Structures and classes have very similar capabilites +struct NamesTable { + let names = [String]() + + // Custom subscript + subscript(index: Int) -> String { + return names[index] + } +} + +// Structures have an auto-generated (implicit) designated initializer +let namesTable = NamesTable(names: ["Me", "Them"]) +let name = namesTable[1] +print("Name is \(name)") // Name is Them + +// +// MARK: Classes +// + +// Classes, structures and its members have three levels of access control +// They are: internal (default), public, private + +public class Shape { + public func getArea() -> Int { + return 0; + } +} + +// All methods and properties of a class are public. +// If you just need to store data in a +// structured object, you should use a `struct` + +internal class Rect: Shape { + var sideLength: Int = 1 + + // Custom getter and setter property + private var perimeter: Int { + get { + return 4 * sideLength + } + set { + // `newValue` is an implicit variable available to setters + sideLength = newValue / 4 + } + } + + // Lazily load a property + // subShape remains nil (uninitialized) until getter called + lazy var subShape = Rect(sideLength: 4) + + // If you don't need a custom getter and setter, + // but still want to run code before and after getting or setting + // a property, you can use `willSet` and `didSet` + var identifier: String = "defaultID" { + // the `willSet` arg will be the variable name for the new value + willSet(someIdentifier) { + print(someIdentifier) + } + } + + init(sideLength: Int) { + self.sideLength = sideLength + // always super.init last when init custom properties + super.init() + } + + func shrink() { + if sideLength > 0 { + --sideLength + } + } + + override func getArea() -> Int { + return sideLength * sideLength + } +} + +// A simple class `Square` extends `Rect` +class Square: Rect { + convenience init() { + self.init(sideLength: 5) + } +} + +var mySquare = Square() +print(mySquare.getArea()) // 25 +mySquare.shrink() +print(mySquare.sideLength) // 4 + +// cast instance +let aShape = mySquare as Shape + +// compare instances, not the same as == which compares objects (equal to) +if mySquare === mySquare { + print("Yep, it's mySquare") +} + +// Optional init +class Circle: Shape { + var radius: Int + override func getArea() -> Int { + return 3 * radius * radius + } + + // Place a question mark postfix after `init` is an optional init + // which can return nil + init?(radius: Int) { + self.radius = radius + super.init() + + if radius <= 0 { + return nil + } + } +} + +var myCircle = Circle(radius: 1) +print(myCircle?.getArea()) // Optional(3) +print(myCircle!.getArea()) // 3 +var myEmptyCircle = Circle(radius: -1) +print(myEmptyCircle?.getArea()) // "nil" +if let circle = myEmptyCircle { + // will not execute since myEmptyCircle is nil + print("circle is not nil") +} + + +// +// MARK: Enums +// + +// Enums can optionally be of a specific type or on their own. +// They can contain methods like classes. + +enum Suit { + case Spades, Hearts, Diamonds, Clubs + func getIcon() -> String { + switch self { + case .Spades: return "♤" + case .Hearts: return "♡" + case .Diamonds: return "♢" + case .Clubs: return "♧" + } + } +} + +// Enum values allow short hand syntax, no need to type the enum type +// when the variable is explicitly declared +var suitValue: Suit = .Hearts + +// Non-Integer enums require direct raw value assignments +enum BookName: String { + case John = "John" + case Luke = "Luke" +} +print("Name: \(BookName.John.rawValue)") + +// Enum with associated Values +enum Furniture { + // Associate with Int + case Desk(height: Int) + // Associate with String and Int + case Chair(String, Int) + + func description() -> String { + switch self { + case .Desk(let height): + return "Desk with \(height) cm" + case .Chair(let brand, let height): + return "Chair of \(brand) with \(height) cm" + } + } +} + +var desk: Furniture = .Desk(height: 80) +print(desk.description()) // "Desk with 80 cm" +var chair = Furniture.Chair("Foo", 40) +print(chair.description()) // "Chair of Foo with 40 cm" + + +// +// MARK: Protocols +// + +// `protocol`s can require that conforming types have specific +// instance properties, instance methods, type methods, +// operators, and subscripts. + +protocol ShapeGenerator { + var enabled: Bool { get set } + func buildShape() -> Shape +} + +// Protocols declared with @objc allow optional functions, +// which allow you to check for conformance +@objc protocol TransformShape { + optional func reshaped() + optional func canReshape() -> Bool +} + +class MyShape: Rect { + var delegate: TransformShape? + + func grow() { + sideLength += 2 + + // Place a question mark after an optional property, method, or + // subscript to gracefully ignore a nil value and return nil + // instead of throwing a runtime error ("optional chaining"). + if let allow = self.delegate?.canReshape?() { + // test for delegate then for method + self.delegate?.reshaped?() + } + } +} + + +// +// MARK: Other +// + +// `extension`s: Add extra functionality to an already existing type + +// Square now "conforms" to the `Printable` protocol +extension Square: Printable { + var description: String { + return "Area: \(self.getArea()) - ID: \(self.identifier)" + } +} + +print("Square: \(mySquare)") + +// You can also extend built-in types +extension Int { + var customProperty: String { + return "This is \(self)" + } + + func multiplyBy(num: Int) -> Int { + return num * self + } +} + +print(7.customProperty) // "This is 7" +print(14.multiplyBy(3)) // 42 + +// Generics: Similar to Java and C#. Use the `where` keyword to specify the +// requirements of the generics. + +func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { + for (index, value) in enumerate(array) { + if value == valueToFind { + return index + } + } + return nil +} +let foundAtIndex = findIndex([1, 2, 3, 4], 3) +print(foundAtIndex == 2) // true + +// Operators: +// Custom operators can start with the characters: +// / = - + * % < > ! & | ^ . ~ +// or +// Unicode math, symbol, arrow, dingbat, and line/box drawing characters. +prefix operator !!! {} + +// A prefix operator that triples the side length when used +prefix func !!! (inout shape: Square) -> Square { + shape.sideLength *= 3 + return shape +} + +// current value +print(mySquare.sideLength) // 4 + +// change side length using custom !!! operator, increases size by 3 +!!!mySquare +print(mySquare.sideLength) // 12 +``` diff --git a/tcl.html.markdown b/tcl.html.markdown new file mode 100644 index 00000000..b90bd690 --- /dev/null +++ b/tcl.html.markdown @@ -0,0 +1,454 @@ +--- +language: Tcl +contributors: + - ["Poor Yorick", "http://pooryorick.com/"] +filename: learntcl.tcl +--- + +Tcl was created by [John Ousterhout](http://wiki.tcl.tk/John Ousterout) as a +reusable scripting language for chip design tools he was creating. In 1997 he +was awarded the [ACM Software System +Award](http://en.wikipedia.org/wiki/ACM_Software_System_Award) for Tcl. Tcl +can be used both as an embeddable scripting language and as a general +programming language. It can also be used as a portable C library, even in +cases where no scripting capability is needed, as it provides data structures +such as dynamic strings, lists, and hash tables. The C library also provides +portable functionality for loading dynamic libraries, string formatting and +code conversion, filesystem operations, network operations, and more. +Various features of Tcl stand out: + +* Convenient cross-platform networking API + +* Fully virtualized filesystem + +* Stackable I/O channels + +* Asynchronous to the core + +* Full coroutines + +* A threading model recognized as robust and easy to use + + +If Lisp is a list processor, then Tcl is a string processor. All values are +strings. A list is a string format. A procedure definition is a string +format. To achieve performance, Tcl internally caches structured +representations of these values. The list commands, for example, operate on +the internal cached representation, and Tcl takes care of updating the string +representation if it is ever actually needed in the script. The copy-on-write +design of Tcl allows script authors can pass around large data values without +actually incurring additional memory overhead. Procedures are automatically +byte-compiled unless they use the more dynamic commands such as "uplevel", +"upvar", and "trace". + +Tcl is a pleasure to program in. It will appeal to hacker types who find Lisp, +Forth, or Smalltalk interesting, as well as to engineers and scientists who +just want to get down to business with a tool that bends to their will. Its +discipline of exposing all programmatic functionality as commands, including +things like loops and mathematical operations that are usually baked into the +syntax of other languages, allows it to fade into the background of whatever +domain-specific functionality a project needs. It's syntax, which is even +lighter that that of Lisp, just gets out of the way. + + + + + +```tcl +#! /bin/env tclsh + +################################################################################ +## 1. Guidelines +################################################################################ + +# Tcl is not Bash or C! This needs to be said because standard shell quoting +# habits almost work in Tcl and it is common for people to pick up Tcl and try +# to get by with syntax they know from another language. It works at first, +# but soon leads to frustration with more complex scripts. + +# Braces are just a quoting mechanism, not a code block constructor or a list +# constructor. Tcl doesn't have either of those things. Braces are used, +# though, to escape special characters in procedure bodies and in strings that +# are formatted as lists. + + +################################################################################ +## 2. Syntax +################################################################################ + +# Every line is a command. The first word is the name of the command, and +# subsequent words are arguments to the command. Words are delimited by +# whitespace. Since every word is a string, in the simple case no special +# markup such as quotes, braces, or backslash, is necessary. Even when quotes +# are used, they are not a string constructor, but just another escaping +# character. + +set greeting1 Sal +set greeting2 ut +set greeting3 ations + + +#semicolon also delimits commands +set greeting1 Sal; set greeting2 ut; set greeting3 ations + + +# Dollar sign introduces variable substitution +set greeting $greeting1$greeting2$greeting3 + + +# Bracket introduces command substitution. The result of the command is +# substituted in place of the bracketed script. When the "set" command is +# given only the name of a variable, it returns the value of that variable. +set greeting $greeting1$greeting2[set greeting3] + + +# Command substitution should really be called script substitution, because an +# entire script, not just a command, can be placed between the brackets. The +# "incr" command increments the value of a variable and returns its value. +set greeting $greeting[ + incr i + incr i + incr i +] + + +# backslash suppresses the special meaning of characters +set amount \$16.42 + + +# backslash adds special meaning to certain characters +puts lots\nof\n\n\n\n\n\nnewlines + + +# A word enclosed in braces is not subject to any special interpretation or +# substitutions, except that a backslash before a brace is not counted when +# looking for the closing brace +set somevar { + This is a literal $ sign, and this \} escaped + brace remains uninterpreted +} + + +# In a word enclosed in double quotes, whitespace characters lose their special +# meaning +set name Neo +set greeting "Hello, $name" + + +#variable names can be any string +set {first name} New + + +# The brace form of variable substitution handles more complex variable names +set greeting "Hello, ${first name}" + + +# The "set" command can always be used instead of variable substitution +set greeting "Hello, [set {first name}]" + + +# To promote the words within a word to individual words of the current +# command, use the expansion operator, "{*}". +``` + +```tcl +set {*}{name Neo} + +# is equivalent to +set name Neo + + +# An array is a special variable that is a container for other variables. +set person(name) Neo +set person(gender) male +set greeting "Hello, $person(name)" + + +# A namespace holds commands and variables +namespace eval people { + namespace eval person1 { + variable name Neo + } +} + + +#The full name of a variable includes its enclosing namespace(s), delimited by two colons: +set greeting "Hello $people::person1::name" + + + +################################################################################ +## 3. A Few Notes +################################################################################ + +# All other functionality is implemented via commands. From this point on, +# there is no new syntax. Everything else there is to learn about Tcl is about +# the behaviour of individual commands, and what meaning they assign to their +# arguments. + + +# To end up with an interpreter that can do nothing, delete the global +# namespace. It's not very useful to do such a thing, but it illustrates the +# nature of Tcl. +namespace delete :: + + +# Because of name resolution behaviour, it's safer to use the "variable" command to +# declare or to assign a value to a namespace. If a variable called "name" already +# exists in the global namespace, using "set" here will assign a value to the global variable +# instead of creating a new variable in the local namespace. +namespace eval people { + namespace eval person1 { + variable name Neo + } +} + + +# The full name of a variable can always be used, if desired. +set people::person1::name Neo + + + +################################################################################ +## 4. Commands +################################################################################ + +# Math can be done with the "expr" command. +set a 3 +set b 4 +set c [expr {$a + $b}] + +# Since "expr" performs variable substitution on its own, brace the expression +# to prevent Tcl from performing variable substitution first. See +# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions" for details. + + +# The "expr" command understands variable and command substitution +set c [expr {$a + [set b]}] + + +# The "expr" command provides a set of mathematical functions +set c [expr {pow($a,$b)}] + + +# Mathematical operators are available as commands in the ::tcl::mathop +# namespace +::tcl::mathop::+ 5 3 + +# Commands can be imported from other namespaces +namespace import ::tcl::mathop::+ +set result [+ 5 3] + + +# New commands can be created via the "proc" command. +proc greet name { + return "Hello, $name!" +} + +#multiple parameters can be specified +proc greet {greeting name} { + return "$greeting, $name!" +} + + +# As noted earlier, braces do not construct a code block. Every value, even +# the third argument of the "proc" command, is a string. The previous command +# rewritten to not use braces at all: +proc greet greeting\ name return\ \"Hello,\ \$name! + + + +# When the last parameter is the literal value, "args", it collects all extra +# arguments when the command is invoked +proc fold {cmd args} { + set res 0 + foreach arg $args { + set res [$cmd $res $arg] + } +} +fold ::tcl::mathop::* 5 3 3 ;# -> 45 + + +# Conditional execution is implemented as a command +if {3 > 4} { + puts {This will never happen} +} elseif {4 > 4} { + puts {This will also never happen} +} else { + puts {This will always happen} +} + + +# Loops are implemented as commands. The first, second, and third +# arguments of the "for" command are treated as mathematical expressions +for {set i 0} {$i < 10} {incr i} { + set res [expr {$res + $i}] +} + + +# The first argument of the "while" command is also treated as a mathematical +# expression +set i 0 +while {$i < 10} { + incr i 2 +} + + +# A list is a specially-formatted string. In the simple case, whitespace is sufficient to delimit values +set amounts 10\ 33\ 18 +set amount [lindex $amounts 1] + + +# Braces and backslash can be used to format more complex values in a list. A +# list looks exactly like a script, except that the newline character and the +# semicolon character lose their special meanings. This feature makes Tcl +# homoiconic. There are three items in the following list. +set values { + + one\ two + + {three four} + + five\{six + +} + + +# Since a list is a string, string operations could be performed on it, at the +# risk of corrupting the formatting of the list. +set values {one two three four} +set values [string map {two \{} $values] ;# $values is no-longer a \ + properly-formatted listwell-formed list + + +# The sure-fire way to get a properly-formmated list is to use "list" commands +set values [list one \{ three four] +lappend values { } ;# add a single space as an item in the list + + +# Use "eval" to evaluate a value as a script +eval { + set name Neo + set greeting "Hello, $name" +} + + +# A list can always be passed to "eval" as a script composed of a single +# command. +eval {set name Neo} +eval [list set greeting "Hello, $name"] + + +# Therefore, when using "eval", use [list] to build up a desired command +set command {set name} +lappend command {Archibald Sorbisol} +eval $command + + +# A common mistake is not to use list functions when building up a command +set command {set name} +append command { Archibald Sorbisol} +eval $command ;# There is an error here, because there are too many arguments \ + to "set" in {set name Archibald Sorbisol} + + +# This mistake can easily occur with the "subst" command. +set replacement {Archibald Sorbisol} +set command {set name $replacement} +set command [subst $command] +eval $command ;# The same error as before: too many arguments to "set" in \ + {set name Archibald Sorbisol} + + +# The proper way is to format the substituted value using use the "list" +# command. +set replacement [list {Archibald Sorbisol}] +set command {set name $replacement} +set command [subst $command] +eval $command + + +# It is extremely common to see the "list" command being used to properly +# format values that are substituted into Tcl script templates. There are +# several examples of this, below. + + +# The "apply" command evaluates a string as a command. +set cmd {{greeting name} { + return "$greeting, $name!" +}} +apply $cmd Whaddup Neo + + +# The "uplevel" command evaluates a script in some enclosing scope. +proc greet {} { + uplevel {puts "$greeting, $name"} +} + +proc set_double {varname value} { + if {[string is double $value]} { + uplevel [list variable $varname $value] + } else { + error [list {not a double} $value] + } +} + + +# The "upvar" command links a variable in the current scope to a variable in +# some enclosing scope +proc set_double {varname value} { + if {[string is double $value]} { + upvar 1 $varname var + set var $value + } else { + error [list {not a double} $value] + } +} + + +#get rid of the built-in "while" command. +rename ::while {} + + +# Define a new while command with the "proc" command. More sophisticated error +# handling is left as an exercise. +proc while {condition script} { + if {[uplevel 1 [list expr $condition]]} { + uplevel 1 $script + tailcall [namespace which while] $condition $script + } +} + + +# The "coroutine" command creates a separate call stack, along with a command +# to enter that call stack. The "yield" command suspends execution in that +# stack. +proc countdown {} { + #send something back to the initial "coroutine" command + yield + + set count 3 + while {$count > 1} { + yield [incr count -1] + } + return 0 +} +coroutine countdown1 countdown +coroutine countdown2 countdown +puts [countdown 1] ;# -> 2 +puts [countdown 2] ;# -> 2 +puts [countdown 1] ;# -> 1 +puts [countdown 1] ;# -> 0 +puts [coundown 1] ;# -> invalid command name "countdown1" +puts [countdown 2] ;# -> 1 + + +``` + +## Reference + +[Official Tcl Documentation](http://www.tcl.tk/man/tcl/) + +[Tcl Wiki](http://wiki.tcl.tk) + +[Tcl Subreddit](http://www.reddit.com/r/Tcl) diff --git a/tmux.html.markdown b/tmux.html.markdown new file mode 100644 index 00000000..c11da5fc --- /dev/null +++ b/tmux.html.markdown @@ -0,0 +1,251 @@ +--- +category: tool +tool: tmux +contributors: + - ["mdln", "https://github.com/mdln"] +filename: LearnTmux.txt +--- + + +[tmux](http://tmux.sourceforge.net) +is a terminal multiplexer: it enables a number of terminals +to be created, accessed, and controlled from a single screen. tmux +may be detached from a screen and continue running in the background +then later reattached. + + +``` + + tmux [command] # Run a command + # 'tmux' with no commands will create a new session + + new # Create a new session + -s "Session" # Create named session + -n "Window" # Create named Window + -c "/dir" # Start in target directory + + attach # Attach last/available session + -t "#" # Attach target session + -d # Detach the session from other instances + + ls # List open sessions + -a # List all open sessions + + lsw # List windows + -a # List all windows + -s # List all windows in session + + lsp # List panes + -a # List all panes + -s # List all panes in session + -t # List app panes in target + + kill-window # Kill current window + -t "#" # Kill target window + -a # Kill all windows + -a -t "#" # Kill all windows but the target + + kill-session # Kill current session + -t "#" # Kill target session + -a # Kill all sessions + -a -t "#" # Kill all sessions but the target + +``` + + +### Key Bindings + +The method of controlling an attached tmux session is via key +combinations called 'Prefix' keys. + +``` +---------------------------------------------------------------------- + (C-b) = Ctrl + b # 'Prefix' combination required to use keybinds + + (M-1) = Meta + 1 -or- Alt + 1 +---------------------------------------------------------------------- + + ? # List all key bindings + : # Enter the tmux command prompt + r # Force redraw of the attached client + c # Create a new window + + ! # Break the current pane out of the window. + % # Split the current pane into two, left and right + " # Split the current pane into two, top and bottom + + n # Change to the next window + p # Change to the previous window + { # Swap the current pane with the previous pane + } # Swap the current pane with the next pane + + s # Select a new session for the attached client + interactively + w # Choose the current window interactively + 0 to 9 # Select windows 0 to 9 + + d # Detach the current client + D # Choose a client to detach + + & # Kill the current window + x # Kill the current pane + + Up, Down # Change to the pane above, below, left, or right + Left, Right + + M-1 to M-5 # Arrange panes: + # 1) even-horizontal + # 2) even-vertical + # 3) main-horizontal + # 4) main-vertical + # 5) tiled + + C-Up, C-Down # Resize the current pane in steps of one cell + C-Left, C-Right + + M-Up, M-Down # Resize the current pane in steps of five cells + M-Left, M-Right + +``` + + +### Configuring ~/.tmux.conf + +tmux.conf can be used to set options automatically on start up, much +like how .vimrc or init.el are used. + +``` +# Example tmux.conf +# 2014.10 + + +### General +########################################################################### + +# Enable UTF-8 +setw -g utf8 on +set-option -g status-utf8 on + +# Scrollback/History limit +set -g history-limit 2048 + +# Index Start +set -g base-index 1 + +# Mouse +set-option -g mouse-select-pane on + +# Force reload of config file +unbind r +bind r source-file ~/.tmux.conf + + +### Keybinds +########################################################################### + +# Unbind C-b as the default prefix +unbind C-b + +# Set new default prefix +set-option -g prefix ` + +# Return to previous window when prefix is pressed twice +bind C-a last-window +bind ` last-window + +# Allow swapping C-a and ` using F11/F12 +bind F11 set-option -g prefix C-a +bind F12 set-option -g prefix ` + +# Keybind preference +setw -g mode-keys vi +set-option -g status-keys vi + +# Moving between panes with vim movement keys +bind h select-pane -L +bind j select-pane -D +bind k select-pane -U +bind l select-pane -R + +# Window Cycle/Swap +bind e previous-window +bind f next-window +bind E swap-window -t -1 +bind F swap-window -t +1 + +# Easy split pane commands +bind = split-window -h +bind - split-window -v +unbind '"' +unbind % + +# Activate inner-most session (when nesting tmux) to send commands +bind a send-prefix + + +### Theme +########################################################################### + +# Statusbar Color Palatte +set-option -g status-justify left +set-option -g status-bg black +set-option -g status-fg white +set-option -g status-left-length 40 +set-option -g status-right-length 80 + +# Pane Border Color Palette +set-option -g pane-active-border-fg green +set-option -g pane-active-border-bg black +set-option -g pane-border-fg white +set-option -g pane-border-bg black + +# Message Color Palette +set-option -g message-fg black +set-option -g message-bg green + +# Window Status Color Palette +setw -g window-status-bg black +setw -g window-status-current-fg green +setw -g window-status-bell-attr default +setw -g window-status-bell-fg red +setw -g window-status-content-attr default +setw -g window-status-content-fg yellow +setw -g window-status-activity-attr default +setw -g window-status-activity-fg yellow + + +### UI +########################################################################### + +# Notification +setw -g monitor-activity on +set -g visual-activity on +set-option -g bell-action any +set-option -g visual-bell off + +# Automatically set window titles +set-option -g set-titles on +set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not) + +# Statusbar Adjustments +set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]" + +# Show performance counters in statusbar +# Requires https://github.com/thewtex/tmux-mem-cpu-load/ +set -g status-interval 4 +set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]" + +``` + + +### References + +[Tmux | Home](http://tmux.sourceforge.net) + +[Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux) + +[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux) + +[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux) + +[Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux) diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown new file mode 100644 index 00000000..baca4217 --- /dev/null +++ b/tr-tr/brainfuck-tr.html.markdown @@ -0,0 +1,87 @@ +--- +language: brainfuck +filename: brainfuck-tr +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io"] +translators: + - ["Haydar KULEKCI", "http://scanf.info/"] +lang: tr-tr +--- + +Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) +son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen +Turing'dir. + +``` +"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter +gözardı edilir. + +Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir +dizidir. İşaretçi ilk hücreyi işaret eder. + +Sekik komut vardır: ++ : Geçerli hücrenin değerini bir artırır. +- : Geçerli hücrenin değerini bir azaltır. +> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye). +< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye). +. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A'). +, : Bir girdilik karakteri aktif hücre için okur. +[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar. + Diğer durumlarda bir sonraki yönergeye geçer. +] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer. + Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner. + +[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar. + +Basit bir brainfuck programına göz atalım. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır. +#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve +#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye +geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez +azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar). + +Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri +60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz. +#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını +yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır. + + +, [ > + < - ] > . + +Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır, +ve daha sonra aynı karakteri ekrana yazdırır. + +, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü +başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1 +hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin +değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü +biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda +#2 hücresinin ASCII değerini yazdırıyoruz. + +Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de +yazabilirsiniz. + +,[>+<-]>. + + +Bu uygulamanın ne yaptığına bakalım: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Bu program 2 sayı alır, ve birbiri ile çarpar. + +Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir +döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü +daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç +döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4 +hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye +kopyalıyoruz. +``` + +İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı +yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz. +Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir +brainfuck yorumlayıcısı yazmayı deneyebilirsiniz. diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown new file mode 100644 index 00000000..128901de --- /dev/null +++ b/tr-tr/c-tr.html.markdown @@ -0,0 +1,488 @@ +--- +name: c +category: language +language: c +filename: learnc-tr.c +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Haydar KULEKCI", "http://scanf.info/"] +lang: tr-tr + +--- +/* +C halen modern yüksek performans bilgisayarların dili. + +C bir çok programcının kullandığı en düşük seviye dillerdendir, ama +salt hız ile daha fazlasını karşılar. C'nin bellek yönetiminden iyi +anlarsanız sizi isteğiniz yere götürecektir. + +```c +// Tek satır yorum // karakterleri ile başlar + +/* +Çoklu satırlı yorumlar bu şekilde görünür. +*/ + +// C Standart kütüphanelerini uygulamanıza #include<ornek.h> ile +// dahil edebilirsiniz. +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// Kendi başlık(header) dosyalarınız dahil etmek için "çift tırnak" +// kullanmalısınız. +#include "my_header.h" + +// Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta +// tanımlayın. + +void function_1(); +void function_2(); + +// Programınızın giriş noktası main isimli bir fonksiyondur ve +// integer değer döner +int main() { + + // çıktıları yazdırmak için printf kullanılır, "print formatted" + // %d bir sayı tipidir, \n yeni satır karakteridir + printf("%d\n", 0); // => 0 karakteri yazdırılır. + // Tüm ifadeler noktalı virgül ile bitmelidir. + + /////////////////////////////////////// + // Tipler + /////////////////////////////////////// + + // Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken + // tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler. + + // int değişken tipi 4 byte boyutundadır. + int x_int = 0; + + // short değişken tipi genellikle 2 byte boyutundadır. + short x_short = 0; + + // char tipi 1 byte boyutunu garanti eder. + char x_char = 0; + char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır. + + // long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler. + long x_long = 0; + long long x_long_long = 0; + + // float tipi 32-bit kayan noktalı sayı boyutundadır. + float x_float = 0.0; + + // double değişken tipi 64-bit kayan noktalı yazı tipindedir. + double x_double = 0.0; + + // Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer + // olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum + // değeri işaretli bir sayının maksimum değeriden büyük olur. + unsigned char ux_char; + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler + // makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte + // cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir + // şekilde ifade edilebilir + // Örneğin, + printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words) + + // If the argument of the `sizeof` operator an expression, then its argument + // is not evaluated (except VLAs (see below)). + // The value it yields in this case is a compile-time constant. + int a = 1; + + // size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir + // işaretsiz tam sayı tipidir + + size_t size = sizeof(a++); // a++ is not evaluated + printf("sizeof(a++) = %zu where a = %d\n", size, a); + // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture) + + // Diziler somut bir boyut ile oluşturulmalıdır. + char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar + int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar + // (4-byte bir word varsayılır) + + // Şu şekilde bir diziyi 0 ile oluşturabilirsiniz: + char my_array[20] = {0}; + + // Dizinin elemanlarını indexlemek diğer diller gibidir, veya + // diğer diller C gibi. + my_array[0]; // => 0 + + // Diziler değişebilirdir (mutable); O sadece memory! + my_array[1] = 2; + printf("%d\n", my_array[1]); // => 2 + + // In C99 (and as an optional feature in C11), variable-length arrays (VLAs) + // can be declared as well. The size of such an array need not be a compile + // time constant: + printf("Enter the array size: "); // ask the user for an array size + char buf[0x100]; + fgets(buf, sizeof buf, stdin); + + // strtoul parses a string to an unsigned integer + size_t size = strtoul(buf, NULL, 10); + int var_length_array[size]; // declare the VLA + printf("sizeof array = %zu\n", sizeof var_length_array); + + // A possible outcome of this program may be: + // > Enter the array size: 10 + // > sizeof array = 40 + + // String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir, + // bu string içerisinde özel bir karakter olan '\0' ile gösterilir. + // (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek + // yoktur; derleyici onu bizim için dizinin sonuna ekler.) + char a_string[20] = "This is a string"; + printf("%s\n", a_string); // %s bir string formatıdır. + + /* + a_string 16 karakter uzunluğundadır. + 17. karakter NUL karakteridir. + 18., 19. ve 20. karakterler tanımsızdır.(undefined) + */ + + printf("%d\n", a_string[16]); // => 0 + // i.e., byte #17 is 0 (as are 18, 19, and 20) + + // If we have characters between single quotes, that's a character literal. + // It's of type `int`, and *not* `char` (for historical reasons). + int cha = 'a'; // fine + char chb = 'a'; // fine too (implicit conversion from int to char) + + /////////////////////////////////////// + // Operatörler + /////////////////////////////////////// + + int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol. + float f1 = 1.0, f2 = 2.0; + + // Aritmatik basittir. + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.) + + f1 / f2; // => 0.5, artı veya eksi epsilon + + // Modüler aritmetikte vardır. + 11 % 3; // => 2 + + // Karşılaştırma operatörleri muhtemelen tanıdıktır, ama + // C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız. + // 0 false yerine ve diğer herşey true yerine geçmektedir. + // (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.) + 3 == 2; // => 0 (false) + 3 != 2; // => 1 (true) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // Sayılar üzerinde mantık işlemleri + !3; // => 0 (Logical not) + !0; // => 1 + 1 && 1; // => 1 (Logical and) + 0 && 1; // => 0 + 0 || 1; // => 1 (Logical or) + 0 || 0; // => 0 + + // Bit boyutunda işlem yapmak için operatörler + ~0x0F; // => 0xF0 (bitwise negation) + 0x0F & 0xF0; // => 0x00 (bitwise AND) + 0x0F | 0xF0; // => 0xFF (bitwise OR) + 0x04 ^ 0x0F; // => 0x0B (bitwise XOR) + 0x01 << 1; // => 0x02 (bitwise left shift (by 1)) + 0x02 >> 1; // => 0x01 (bitwise right shift (by 1)) + + // Be careful when shifting signed integers - the following are undefined: + // - shifting into the sign bit of a signed integer (int a = 1 << 32) + // - left-shifting a negative number (int a = -1 << 2) + // - shifting by an offset which is >= the width of the type of the LHS: + // int a = 1 << 32; // UB if int is 32 bits wide + + /////////////////////////////////////// + // Kontrol Yapıları + /////////////////////////////////////// + + if (0) { + printf("I am never run\n"); + } else if (0) { + printf("I am also never run\n"); + } else { + printf("I print\n"); + } + + // While Döngüsü + int ii = 0; + while (ii < 10) { + printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır. + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + int kk = 0; + do { + printf("%d, ", kk); + } while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır. + // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // For Döngüsü + int jj; + for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); + } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + /////////////////////////////////////// + // Tip Dönüşümleri + /////////////////////////////////////// + + // C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe + // dönüştürebilirsiniz. + + int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz. + + // Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır. + printf("%d\n", x_hex); // => Prints 1 + printf("%d\n", (short) x_hex); // => Prints 1 + printf("%d\n", (char) x_hex); // => Prints 1 + + // Tip hiçbir hata vermeden taşacaktır(overflow). + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 eğer karakter 8 bit uzunluğunda ise) + + // `char`, `signed char` ve `unsigned char` karakter tiplerinin maksimum uzunluğunu + // belirlemek için <limits.h> kütüphanesindeki CHAR_MAX, SCHAR_MAX ve UCHAR_MAX + // macrolarını kullanınız. + + // Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi. + printf("%f\n", (float)100); // %f formats a float + printf("%lf\n", (double)100); // %lf formats a double + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // İşaretçiler (Pointers) + /////////////////////////////////////// + + // Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret + // edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini + // getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz. + + int x = 0; + printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır. + // (%p işaretçilerin formatıdır) + // => Bazı bellek adresleri yazdırılacaktır. + + + // İşaretçiler tanımlanırken * ile başlar + int *px, not_a_pointer; // px sayı tipinde bir işaretçidir. + px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır. + printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır. + printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer)); + // => 64-bit sistemde "8, 4" yazdırılacaktır. + + // İşaretçinin adres olarak gösterdiği yerdeki değeri almak için + // değişkenin önüne * işareti ekleyiniz. + printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir, + // çünkü px değişkeni x in adresini göstermektedir. + + // Ayrıca siz işaretçinin gösterdiği yerin değerini + // değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz + // çünkü ++ işleminin önceliği * işleminden yüksektir. + (*px)++; // px'in işaret ettiği değeri 1 artır. + printf("%d\n", *px); // => 1 yazdırılır. + printf("%d\n", x); // => 1 yazdırılır. + + int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını + // tahsis etmek için iyi bir yöntemdir. + int xx; + for (xx=0; xx<20; xx++) { + x_array[xx] = 20 - xx; + } // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor. + + // Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor. + int* x_ptr = x_array; + // x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20). + // Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk + // elemanlarını gösteren birer işaretçidir. + // For example, when an array is passed to a function or is assigned to a pointer, + // it decays into (implicitly converted to) a pointer. + // Exceptions: when the array is the argument of the `&` (address-od) operator: + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`! + // It's of type "pointer to array" (of ten `int`s). + // or when the array is a string literal used for initializing a char array: + char arr[] = "foobarbazquirk"; + // or when it's the argument of the `sizeof` or `alignof` operator: + int arr[10]; + int *ptr = arr; // equivalent with int *ptr = &arr[0]; + printf("%zu %zu\n", sizeof arr, sizeof ptr); // probably prints "40, 4" or "40, 8" + + // Diziler ilk elemanlarını gösteren birer işaretçidirler. + printf("%d\n", *(x_ptr)); // => 20 yazılacaktır. + printf("%d\n", x_array[0]); // => 20 yazılacaktır. + + // İşaretçiler kendi tiplerinde artırılır ve azaltılır. + printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır. + printf("%d\n", x_array[1]); // => 19 yazılacaktır. + + // Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan + // malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon + // byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır. + int* my_ptr = (int*) malloc(sizeof(int) * 20); + for (xx=0; xx<20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir + } // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır. + + // Eğer ayrımadığınız bir bellek adresini çağırırsanız + // öngörülmeyen bir değer dönecektir. + printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak? + + // Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde + // onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız + // kapatılana kadar belleğin o kısmını kimse kullanamaz. + free(my_ptr); + + // Metin Dizileri(String) birer karakter dizisidir(char array), ama + // genelde karakter işaretçisi olarak kullanılır. + char* my_str = "This is my very own string"; + + printf("%c\n", *my_str); // => 'T' + + function_1(); +} // main fonksiyon sonu + +/////////////////////////////////////// +// Fonksiyonlar +/////////////////////////////////////// + +// Fonksiyon tanımlama sözdizimi: +// <return type> <fonksiyon adi>(<args>) + +int add_two_ints(int x1, int x2){ + return x1 + x2; // bir değer geri döndürmek için return kullanılır. +} + +/* +Fonksiyonlar pass-by-value'dür, ama isterseniz işaretçi referanslarını +kullanarak fonksiyona gönderilen parametrenin değerini değiştirebilirsiniz. + +Example: Bir metni tersine çevirme +*/ + +// Bir void konksiyonu hiç bir değer dönmez +void str_reverse(char* str_in){ + char tmp; + int ii=0, len = strlen(str_in); // Strlen C'nin standart kütüphanesinin bir fonksiyonu + for(ii=0; ii<len/2; ii++){ + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // sondan ii'inci elemanı + str_in[len - ii - 1] = tmp; + } +} + +/* +char c[] = "This is a test."; +str_reverse(c); +printf("%s\n", c); // => ".tset a si sihT" +*/ + +/////////////////////////////////////// +// Kullanıcı Tanımlı Tipler ve Yapılar +/////////////////////////////////////// + +// Typedef'ler bir tip takma adı oluşturur. +typedef int my_type; +my_type my_type_var = 0; + +// Struct'lar bir veri koleksiyonudur. +struct rectangle { + int width; + int height; +}; + +// It's not generally true that +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) +// due to potential padding between the structure members (this is for alignment +// reasons). [1] + +void function_1(){ + + struct rectangle my_rec; + + // "." ile yapı üyelerine ulaşılabilir. + my_rec.width = 10; + my_rec.height = 20; + + // Bir yapının adresini işaretçiye atayabilirsiniz. + struct rectangle* my_rec_ptr = &my_rec; + + // İşaretçi üzerinden bir yapıya ulaşabilirsiniz. + (*my_rec_ptr).width = 30; + + // ya da -> işareti ile yapının elemanlarına ulaşabilirsiniz. + my_rec_ptr->height = 10; // (*my_rec_ptr).height = 10; ile aynıdır. +} + +// Kolaylık sağlamak için bir yapıya typedef tanımlayabilirsiniz. +typedef struct rectangle rect; + +int area(rect r){ + return r.width * r.height; +} + +/////////////////////////////////////// +// Fonksiyon İşaretçiler +/////////////////////////////////////// + +/* +Çalışma zamanında, fonksiyonların bilinen bir bellek adresleri vardır. Fonksiyon +işaretçileri fonksiyonları direk olarak çağırmayı sağlayan veya geri bildirim(callback) +için parametre gönderirken kullanılan başka birer işaretçidirler. Ama, syntax tanımı +başlangıçta biraz karışık gelebilir. + +Örnek: bir işaretçiden str_reverse kullanımı +*/ +void str_reverse_through_pointer(char * str_in) { + // f adında bir fonksiyon işaretçisi tanımlanır. + void (*f)(char *); // Signature should exactly match the target function. + f = &str_reverse; // Assign the address for the actual function (determined at runtime) + (*f)(str_in); // Just calling the function through the pointer + // f(str_in); // That's an alternative but equally valid syntax for calling it. +} + +/* +As long as function signatures match, you can assign any function to the same pointer. +Function pointers are usually typedef'd for simplicity and readability, as follows: +*/ + +typedef void (*my_fnp_type)(char *); + +// Gerçek bir işaretçi tanımlandığı zaman ki kullanımı: +// ... +// my_fnp_type f; + +``` + +## Daha Fazla Okuma Listesi + +[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)'in bir kopyasını bulundurmak mükemmel olabilir + +Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/) + +It's very important to use proper spacing, indentation and to be consistent with your coding style in general. +Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the +[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle). + +Diğer taraftan google sizin için bir arkadaş olabilir. + +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
\ No newline at end of file diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown new file mode 100644 index 00000000..91c7c269 --- /dev/null +++ b/tr-tr/csharp-tr.html.markdown @@ -0,0 +1,825 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] + - ["Melvyn Laïly", "http://x2a.yt"] + - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] +translators: + - ["Melih Mucuk", "http://melihmucuk.com"] +lang: tr-tr +filename: LearnCSharp-tr.cs + +--- + +C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar. + +[Yazım yanlışları ve öneriler için bana ulaşabilirsiniz](mailto:melihmucuk@gmail.com) + +[Daha fazlasını okuyun.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx) + +```c# +// Tek satırlık yorumlar // ile başlar +/* +Birden fazla satırlı yorumlar buna benzer +*/ +/// <summary> +/// Bu bir XML dokümantasyon yorumu +/// </summary> + +// Uygulamanın kullanacağı ad alanlarını belirtin +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Dynamic; +using System.Linq; +using System.Linq.Expressions; +using System.Net; +using System.Threading.Tasks; +using System.IO; + +// Kodu düzenlemek için paketler içinde alan tanımlayın +namespace Learning +{ + // Her .cs dosyası, dosya ile aynı isimde en az bir sınıf içermeli + // bu kurala uymak zorunda değilsiniz ancak mantıklı olan yol budur. + public class LearnCSharp + { + // TEMEL SÖZ DİZİMİ - daha önce Java ya da C++ kullandıysanız İLGİNÇ ÖZELLİKLER'e geçin + public static void Syntax() + { + // Satırları yazdırmak için Console.WriteLine kullanın + Console.WriteLine("Merhaba Dünya"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Yeni satıra geçmeden yazdırmak için Console.Write kullanın + Console.Write("Merhaba "); + Console.Write("Dünya"); + + /////////////////////////////////////////////////// + // Tipler & Değişkenler + // + // Bir değişken tanımlamak için <tip> <isim> kullanın + /////////////////////////////////////////////////// + + // Sbyte - Signed 8-bit integer + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Unsigned 8-bit integer + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - 16-bit integer + // Signed - (-32,768 <= short <= 32,767) + // Unsigned - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Integer - 32-bit integer + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - 64-bit integer + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir. + // L, değişken değerinin long ya da ulong tipinde olduğunu belirtmek için kullanılır. + + // Double - Çift hassasiyetli 64-bit IEEE 754 kayan sayı + double fooDouble = 123.4; // Hassasiyet: 15-16 basamak + + // Float - Tek hassasiyetli 32-bit IEEE 754 kayan sayı + float fooFloat = 234.5f; // Hassasiyet: 7 basamak + // f, değişken değerinin float tipinde olduğunu belirtmek için kullanılır. + + // Decimal - 128-bit veri tiğinde ve diğer kayan sayı veri tiplerinden daha hassastır, + // finansal ve mali hesaplamalar için uygundur. + decimal fooDecimal = 150.3m; + + // Boolean - true & false + bool fooBoolean = true; // veya false + + // Char - 16-bitlik tek bir unicode karakter + char fooChar = 'A'; + + // Strings -- Önceki baz tiplerinin hepsi değer tipiyken, + // string bir referans tipidir. Null değer atayabilirsiniz + string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; + Console.WriteLine(fooString); + + // İndeks numarası kullanarak bir string'in bütün karakterlerine erişilebilirsiniz: + char charFromString = fooString[1]; // => 'e' + // String'ler değiştirilemez: fooString[1] = 'X' işlemini yapamazsınız; + + // String'leri geçerli kültür değeri ve büyük küçük harf duyarlılığı olmadan karşılaştırma + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // sprintf baz alınarak formatlama + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // Tarihler & Formatlama + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // Bir string'i iki satıra bölmek için @ sembolü kullanabilirsiniz. " işaretinden kaçmak için "" kullanın + string bazString = @"Here's some stuff +on a new line! ""Wow!"", the masses cried"; + + // Bir değişkeni değiştirilemez yapmak için const ya da read-only kullanın. + // const değerleri derleme sırasında hesaplanır + const int HOURS_I_WORK_PER_WEEK = 9001; + + /////////////////////////////////////////////////// + // Veri Yapıları + /////////////////////////////////////////////////// + + // Diziler - Sıfır indeksli + // Dizi boyutuna tanımlama sırasında karar verilmelidir. + // Dizi tanımlama formatı şöyledir: + // <veri tipi>[] <değişken ismi> = new <veri tipi>[<dizi boyutu>]; + int[] intArray = new int[10]; + + // Bir diğer dizi tanımlama formatı şöyledir: + int[] y = { 9000, 1000, 1337 }; + + // Bir diziyi indeksleme - Bir elemente erişme + Console.WriteLine("intArray @ 0: " + intArray[0]); + // Diziler değiştirilebilir. + intArray[1] = 1; + + // Listeler + // Listeler daha esnek oldukları için dizilerden daha sık kullanılırlar. + // Bir liste tanımlama formatı şöyledir: + // List<veri tipi> <değişken ismi> = new List<veri tipi>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // tanımlama + // <> işareti generic ifadeler içindir - Güzel özellikler sekmesini inceleyin + + // Listelerin varsayılan bir değeri yoktur; + // İndekse erişmeden önce değer eklenmiş olmalıdır + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + // Diğer veri yapıları için şunlara bakın: + // Stack/Queue (Yığın/Kuyruk) + // Dictionary (hash map'in uygulanması) (Sözlük) + // HashSet (karma seti) + // Read-only Collections (Değiştirilemez koleksiyonlar) + // Tuple (.Net 4+) (tüp) + + /////////////////////////////////////// + // Operatörler + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // Birden çok tanımlamanın kısa yolu + + // Aritmetik basittir + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // Mod + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Karşılaştırma operatörleri + Console.WriteLine("3 == 2? " + (3 == 2)); // => false + Console.WriteLine("3 != 2? " + (3 != 2)); // => true + Console.WriteLine("3 > 2? " + (3 > 2)); // => true + Console.WriteLine("3 < 2? " + (3 < 2)); // => false + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true + + // Bit düzeyi operatörleri! + /* + ~ Tekli bit tamamlayıcısı + << Sola kaydırma Signed left shift + >> Sağa kaydırma Signed right shift + & Bit düzeyi AND + ^ Bit düzeyi harici OR + | Bit düzeyi kapsayan OR + */ + + // Arttırma + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. Post-Incrementation + Console.WriteLine(++i); //i = 2. Pre-Incrementation + Console.WriteLine(i--); //i = 1. Post-Decrementation + Console.WriteLine(--i); //i = 0. Pre-Decrementation + + /////////////////////////////////////// + // Kontrol Yapıları + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // If ifadesi c benzeridir + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // Üçlü operatörler + // Basit bir if/else ifadesi şöyle yazılabilir + // <koşul> ? <true> : <false> + int toCompare = 17; + string isTrue = toCompare == 17 ? "True" : "False"; + + // While döngüsü + int fooWhile = 0; + while (fooWhile < 100) + { + //100 kere tekrarlanır, fooWhile 0->99 + fooWhile++; + } + + // Do While Döngüsü + int fooDoWhile = 0; + do + { + //100 kere tekrarlanır, fooDoWhile 0->99 + fooDoWhile++; + } while (fooDoWhile < 100); + + //for döngüsü yapısı => for(<başlangıç ifadesi>; <koşul>; <adım>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + //10 kere tekrarlanır, fooFor 0->9 + } + + // For Each Döngüsü + // foreach döngüsü yapısı => foreach(<yineleyici tipi> <yineleyici ismi> in <enumerable>) + // foreach döngüsü, IEnumerable ya da IEnumerable<T> e dönüştürülmüş herhangi bir obje üzerinde döngü yapabilir + // .Net framework üzerindeki bütün koleksiyon tiplerinden (Dizi, Liste, Sözlük...) + // biri ya da hepsi uygulanarak gerçekleştirilebilir. + // (ToCharArray() silindi, çünkü string'ler aynı zamanda IEnumerable'dır.) + foreach (char character in "Hello World".ToCharArray()) + { + //String içindeki bütün karakterler üzerinde döner + } + + // Switch Case + // Bir switch byte, short, char ve int veri tipleri ile çalışır. + // Aynı zamanda sıralı tipler ile de çalışabilir.(Enum Tipleri bölümünde tartışıldı), + // String sınıfı, ve bir kaç özel sınıf kaydırılır + // basit tipler: Character, Byte, Short, and Integer. + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + // Bir aksiyon için birden fazla durum atayabilirsiniz + // Ancak, break olmadan yeni bir durum ekleyemezsiniz + // (Eğer bunu yapmak istiyorsanız, goto komutu eklemek zorundasınız) + case 6: + case 7: + case 8: + monthString = "Summer time!!"; + break; + default: + monthString = "Some other month"; + break; + } + + /////////////////////////////////////// + // Veri Tipleri Dönüştürme ve Typecasting + /////////////////////////////////////// + + // Veri Dönüştürme + + // String'i Integer'a Dönüştürme + // bu başarısız olursa hata fırlatacaktır + int.Parse("123");// "123" 'in Integer değerini döndürür + + // try parse hata durumunda değişkene varsayılan bir değer atamak için kullanılır + // bu durumda: 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // Fonksiyon boolean'dır + Console.WriteLine(tryInt); // 123 + + // Integer'ı String'e Dönüştürme + // Convert sınıfı dönüştürme işlemini kolaylaştırmak için bir dizi metoda sahiptir + Convert.ToString(123); + // veya + tryInt.ToString(); + } + + /////////////////////////////////////// + // SINIFLAR - dosyanın sonunda tanımları görebilirsiniz + /////////////////////////////////////// + public static void Classes() + { + // Obje tanımlamalarını dosyanın sonunda görebilirsiniz + + // Bir sınıfı türetmek için new kullanın + Bicycle trek = new Bicycle(); + + // Obje metodlarını çağırma + trek.SpeedUp(3); // Her zaman setter ve getter metodları kullanmalısınız + trek.Cadence = 100; + + // ToString objenin değerini göstermek için kullanılır. + Console.WriteLine("trek info: " + trek.Info()); + + // Yeni bir Penny Farthing sınıfı türetmek + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } // Ana metodun sonu + + // KONSOLE BAŞLANGICI Bir konsol uygulaması başlangıç olarak mutlaka ana metod'a sahip olmalı + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // İLGİNÇ ÖZELLİKLER + // + + // VARSAYILAN METOD TANIMLAMALARI + + public // Görünebilir + static // Sınıf üzerinden obje türetmeden çağırılabilir + int // Dönüş Tipi, + MethodSignatures( + int maxCount, // İlk değişken, int değer bekler + int count = 0, // Eğer değer gönderilmezse varsayılan olarak 0 değerini alır + int another = 3, + params string[] otherParams // Metoda gönderilen diğer bütün parametreleri alır + ) + { + return -1; + } + + // Metodlar tanımlamalar benzersiz ise aynı isimleri alabilirler + public static void MethodSignatures(string maxCount) + { + } + + // GENERIC'LER + // TKey ve TValue değerleri kullanıcı tarafından bu fonksiyon çağırılırken belirtilir. + // Bu metod Python'daki SetDefault'a benzer + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // Gönderilen objeleri daraltabilirsiniz + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // Eğer T IEnumerable ise tekrarlayabiliriz + foreach (var item in toPrint) + // Item bir int + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // İSTEĞE BAĞLI PARAMETRELER + MethodSignatures(3, 1, 3, "Some", "Extra", "Strings"); + MethodSignatures(3, another: 3); // isteğe bağlı olanlar gönderilmedi + + // UZANTI METODLARI + int i = 3; + i.Print(); // Aşağıda tanımlandı + + // NULLABLE TYPES - veri tabanı işlemleri için uygun / return values + // Herhangi bir değer tipi sonuna ? eklenerek nullable yapılabilir (sınıflar hariç) + // <tip>? <değiken ismi> = <değer> + int? nullable = null; // Nullable<int> için kısa yol + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // eğer null değilse true döner + + // ?? varsayılan değer belirlemek için söz dizimsel güzel bir özellik + // bu durumda değişken null'dır + int notNullable = nullable ?? 0; // 0 + + // TİPİ BELİRTİLMEMİŞ DEĞİŞKENLER - compiler değişkenin tipini bilmeden çalışabilir: + var magic = "magic is a string, at compile time, so you still get type safety"; + // magic = 9; string gibi çalışmayacaktır, bu bir int değil + + // GENERIC'LER + // + var phonebook = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // Telefon rehberine bir kaç numara ekleyelim. + }; + + // Yukarıda generic olarak tanımlanan SETDEFAULT'u çağırma + Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // Telefonu yok + // TKey ve TValue tipini belirtmek zorunda değilsiniz + Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555 + + // LAMBDA IFADELERİ - satır içinde kod yazmanıza olanak sağlar + Func<int, int> square = (x) => x * x; // Son T nesnesi dönüş değeridir + Console.WriteLine(square(3)); // 9 + + // TEK KULLANIMLIK KAYNAK YÖNETİMİ - Yönetilemeyen kaynakların üstesinden kolayca gelebilirsiniz. + // Bir çok obje yönetilemeyen kaynaklara (dosya yakalama, cihaz içeriği, vb.) + // IDisposable arabirimi ile erişebilir. Using ifadesi sizin için IDisposable objeleri temizler. + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("Nothing suspicious here"); + // Bu bölümün sonunda kaynaklar temilenir. + // Hata fırlatılmış olsa bile. + } + + // PARALEL FRAMEWORK + // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // Her istek farklı bir thread de işlem görecek + // bir sonraki işleme geçmeden birleştirilecek. + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // en fazla 3 thread kullanmak için + website => + { + // Uzun sürecek bir işlem yapın + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // Bütün istekler tamamlanmadan bu döndü çalışmayacaktır. + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // DİNAMİK OBJELER (diğer dillerle çalışırken kullanmak için uygun) + dynamic student = new ExpandoObject(); + student.FirstName = "First Name"; // Önce yeni bir sınıf tanımlamanız gerekmez! + + // Hatta metod bile ekleyebilirsiniz (bir string döner, ve bir string alır) + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - neredeyse bütün koleksiyonlar bundan türer, bu size bir çok + // kullanışlı Map / Filter / Reduce stili metod sağlar. + var bikes = new List<Bicycle>(); + bikes.Sort(); // Dizi sıralama + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Wheels baz alınarak sıralama + var result = bikes + .Where(b => b.Wheels > 3) // Filters- chainable (bir önceki tipin IQueryable'ını döner) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // Map - sadece bunu seçiyoruz, yani sonuç bir IQueryable<string> olacak + + var sum = bikes.Sum(b => b.Wheels); // Reduce - koleksiyonda bulunan bütün wheel değerlerinin toplamı + + // Bike içindeki bazı parametreleri baz alarak bir liste oluşturmak + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // Burada göstermek zor ama, compiler yukaridaki tipleri çözümleyebilirse derlenmeden önce tipi verebilir. + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + // ASPARALLEL + // Linq ve paralel işlemlerini birleştirme + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // bu paralel bir şekilde gerçekleşecek! Threadler otomatik ve sihirli bir şekilde işleri paylaşacak! + // Birden fazla çekirdeğiniz varsa büyük veri setleri ile kullanmak için oldukça uygun bir yapı. + + // LINQ - IQueryable<T> objelerini mapler ve saklar, gecikmeli bir işlemdir + // e.g. LinqToSql - veri tabanını mapler, LinqToXml xml dökümanlarını mapler. + var db = new BikeRepository(); + + // işlem gecikmelidir, bir veri tabanı üzerinde sorgulama yaparken harikadır. + var filter = db.Bikes.Where(b => b.HasTassles); // sorgu henüz çalışmadı + if (42 > 6) // Filtreler eklemeye devam edebilirsiniz - ileri düzey arama fonksiyonları için harikadır + filter = filter.Where(b => b.IsBroken); // sorgu henüz çalışmadı + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // hala sorgu çalışmadı + + // Şimdi sorgu çalışıyor, reader'ı açar ama sadece sizin sorgunuza uyanlar foreach döngüsüne girer. + foreach (string bike in query) + Console.WriteLine(result); + + + + } + + } // LearnCSharp sınıfının sonu + + // Bir .cs dosyasına diğer sınıflarıda dahil edebilirsiniz + + public static class Extensions + { + // UZANTI FONKSİYONLARI + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + + // Sınıf Tanımlama Sözdizimi: + // <public/private/protected/internal> class <sınıf ismi>{ + // //veri alanları, kurucular , fonksiyonlar hepsi içindedir. + // //Fonksiyonlar Java'daki gibi metod olarak çağırılır. + // } + + public class Bicycle + { + // Bicycle'ın Alanları/Değişkenleri + public int Cadence // Public: herhangi bir yerden erişilebilir + { + get // get - değeri almak için tanımlanan metod + { + return _cadence; + } + set // set - değer atamak için tanımlanan metod + { + _cadence = value; // Değer setter'a gönderilen value değeridir + } + } + private int _cadence; + + protected virtual int Gear // Protected: Sınıf ve alt sınıflar tarafından erişilebilir + { + get; // bir üye alanına ihtiyacınız yok, bu otomatik olarak bir değer oluşturacaktır + set; + } + + internal int Wheels // Internal: Assembly tarafından erişilebilir + { + get; + private set; // Nitelik belirleyicileri get/set metodlarında atayabilirsiniz + } + + int _speed; // Her şey varsayılan olarak private'dır : Sadece sınıf içinden erişilebilir. + // İsterseniz yinede private kelimesini kullanabilirsiniz. + public string Name { get; set; } + + // Enum sabitler kümesinden oluşan bir değer tipidir. + // Gerçekten sadece bir isim ile bir değeri tutmak için kullanılır. (aksi belirtilmedikçe bir int'dir). + // İzin verilen enum tipleri şunlardır byte, sbyte, short, ushort, int, uint, long, veya ulong. + // Bir enum aynı değeri birden fazla sayıda barındıramaz. + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, // bir isme tam bir değer verebilirsiniz + Gitane // 43 + } + // Bu tipi Bicycle sınıfı içinde tanımladığımız için bu bir bağımlı tipdir. + // Bu sınıf dışında kullanmak için tipi Bicycle.Brand olarak kullanmamız gerekir + + public BikeBrand Brand; // Enum tipini tanımladıktan sonra alan tipini tanımlayabiliriz + + // Static üyeler belirli bir obje yerine kendi tipine aittir + // Onlara bir obje referans göstermeden erişebilirsiniz: + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + static public int BicyclesCreated = 0; + + // readonly değerleri çalışma zamanında atanır + // onlara sadece tanımlama yapılarak ya da kurucular içinden atama yapılabilir + readonly bool _hasCardsInSpokes = false; // read-only private + + // Kurucular sınıf oluşturmanın bir yoludur + // Bu bir varsayılan kurucudur. + public Bicycle() + { + this.Gear = 1; // bu objenin üyelerine this anahtar kelimesi ile ulaşılır + Cadence = 50; // ama her zaman buna ihtiyaç duyulmaz + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // Bu belirlenmiş bir kurucudur. (argümanlar içerir) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // önce base'i çağırın + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // Kurucular zincirleme olabilir + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // Fonksiyon Sözdizimi: + // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>) + + // sınıflar getter ve setter'ları alanları için kendisi uygular + // veya property'ler eklenebilir (C# da tercih edilen yol budur) + + // Metod parametreleri varsayılan değerlere sahip olabilir. + // Bu durumda, metodlar bu parametreler olmadan çağırılabilir. + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // property'lerin get/set değerleri + // sadece veri gerektiği zaman erişilebilir, kullanmak için bunu göz önünde bulundurun. + // property'ler sadece get ya da set'e sahip olabilir veya ikisine birden + private bool _hasTassles; // private değişken + public bool HasTassles // public accessor + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // Ayrıca tek bir satırda otomatik property tanımlayabilirsiniz. + // bu söz dizimi otomatik olarak alan oluşturacaktır. + // Erişimi kısıtlamak için nitelik belirleyiciler getter veya setter'a ya da ikisine birden atanabilir: + public bool IsBroken { get; private set; } + + // Property'ler otomatik eklenmiş olabilir + public int FrameSize + { + get; + // nitelik beliryecileri get veya set için tanımlayabilirsiniz + // bu sadece Bicycle sınıfı Framesize değerine atama yapabilir demektir + private set; + } + + // Ayrıca obje üzerinde özel indeksleyici belirlemek mümkündür. + // Tüm bunlar bu örnek için çok kullanışlı değil, + // bicycle[0] ile ilk yolcu olan "chris" i almak mümkün veya + // bicycle[1] = "lisa" ile yolcuyu atayabilirsiniz. (bariz quattrocycle) + private string[] passengers = { "chris", "phil", "darren", "regina" } + + public string this[int i] + { + get { + return passengers[i]; + } + + set { + return passengers[i] = value; + } + } + + //Bu objenin nitelik değerlerini göstermek için bir metod. + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Metodlar static olabilir. Yardımcı metodlar için kullanışlı olabilir. + public static bool DidWeCreateEnoughBycles() + { + // Bir static metod içinde sadece static sınıf üyeleri referans gösterilebilir + return BicyclesCreated > 9000; + } // Eğer sınıfınızın sadece static üyelere ihtiyacı varsa, sınıfın kendisini static yapmayı düşünebilirsiniz. + + + } // Bicycle sınıfı sonu + + // PennyFarthing , Bicycle sınıfının alt sınıfıdır. + class PennyFarthing : Bicycle + { + // (Penny Farthing'ler ön jantı büyük bisikletlerdir. + // Vitesleri yoktur.) + + // Ana kurucuyu çağırmak + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + throw new ArgumentException("You can't change gears on a PennyFarthing"); + } + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Metodun temel versiyonunu çağırmak + return result; + } + } + + // Arabirimler sadece üyelerin izlerini içerir, değerlerini değil. + interface IJumpable + { + void Jump(int meters); // bütün arbirim üyeleri public'tir + } + + interface IBreakable + { + bool Broken { get; } // arabirimler property'leri, metodları ve olayları içerebilir + } + + // Sınıflar sadece tek bir sınıftan miras alabilir ama sınırsız sayıda arabirime sahip olabilir + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// LinqToSql örneği veri tabanına bağlanmak için kullanılır. + /// EntityFramework Code First harika! (Ruby'deki ActiveRecord'a benzer, ama iki yönlü) + /// http://msdn.microsoft.com/en-us/data/jj193542.aspx + /// </summary> + public class BikeRepository : DbSet + { + public BikeRepository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // namespace sonu +``` + +## İşlenmeyen Konular + + * Flags + * Attributes + * Static properties + * Exceptions, Abstraction + * ASP.NET (Web Forms/MVC/WebMatrix) + * Winforms + * Windows Presentation Foundation (WPF) + +## Daha Fazlasını Okuyun + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + + + +[C# Kodlama Adetleri](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx) diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown new file mode 100644 index 00000000..bac8f6fc --- /dev/null +++ b/tr-tr/markdown-tr.html.markdown @@ -0,0 +1,251 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators: + - ["Eray AYDIN", "http://erayaydin.me/"] +lang: tr-tr +filename: markdown-tr.md +--- + +Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır. + + +```markdown +<!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir +ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve +markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız, +bu elementin içeriğinde markdown söz dizimlerini kullanamazsınız. --> + +<!-- Markdown ayrıca işleyiciden işleyiciye farklılık gösterebilir. Bu rehberde +evrensel özelliklere uygun anlatımlar olacaktır. Bir çok işleyici bu rehberdeki +anlatımları destekler --> + +<!-- Başlıklar --> +<!-- Kolayca <h1>'den <h6>'ya HTML etiketleri oluşturabilirsiniz. +Kare (#) sayısı bu elementin numarasını belirleyecek ve devamında getirdiğiniz +yazı bu elementin içeriği olacaktır +--> +# Bu bir <h1> +## Bu bir <h2> +### Bu bir <h3> +#### Bu bir <h4> +##### Bu bir <h5> +###### Bu bir <h6> + +<!-- Markdown ayrıca h1 ve h2 için 2 alternatif yol daha taşır --> +Bu bir h1 +========= + +Bu bir h2 +--------- + +<!-- Basit yazı stilleri --> +<!-- Markdown ile yazılar kolayca italik ve kalın belirtilebilir --> +*Bu yazı italik.* +_Bu yazı da italik._ + +**Bu yazı kalın.** +__Bu yazı da kalın.__ + +***Bu yazı hem kalın hem italik.*** +**_Bu da öyle!_** +*__Hatta bu bile!__* + +<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: --> +~~Bu yazı üstü çizili olarak gözükecek.~~ + +<!-- Paragraflar bir veya daha fazla boş satırla ayrılır. --> + +Bu bir paragraf. Paragrafın içeriğine devam ediyorum, eğlenceli değil mi? + +Şimdi 2. paragrafıma geçtim. +Hala 2. paragraftayım, çünkü boş bir satır bırakmadım. + +Bu da 3. paragrafım! + +<!-- HTML'de her satır için <br /> etiketi kullanmak ister misiniz, Bir +paragrafı bitirdikten sonra 2 veya daha fazla boşluk bırakın ve yeni paragrafa +başlayın, bu bir <br /> etiketi sayılacaktır --> + +Bu yazının sonunda 2 boşluk var (bu satırı seçerek kontrol edebilirsiniz). + +Bir üst satırda <br /> etiketi var! + +<!-- Blok yazılarının yapımı oldukça kolay, (>) karakteri ile yapabilirsiniz --> + +> Bu bir blok etiketi. Satırlara ayırmak için +> her satırın başında `>` karakter yerleştirmeli veya tek satırda bütün içeriği yazabilirsiniz. +> Satır `>` karakteri ile başladığı sürece sorun yok. + +> Ayrıca alt alta da blok elementi açabilirsiniz +>> iç içe yani +> düzgün değil mi ? + +<!-- Listeler --> +<!-- Numarasız listeler için yıldız, artı, veya tire kullanabilirsiniz --> + +* Nesne +* Nesne +* Bir başka nesne + +veya + ++ Nesne ++ Nesne ++ Bir başka nesne + +veya + +- Nesne +- Nesne +- Son bir nesne + +<!-- Numaralı liste için başına sıralı bir şekilde sayı eklemeniz yeterli --> + +1. İlk nesne +2. İkinci nesne +3. Üçüncü nesne + +<!-- İsterseniz sıralı bir şekilde yazmak zorunda değilsiniz, markdown +biçimlendirirken sizin için sıralayacaktır, fakat bunu önermiyorum. Markdown dosyasının +düzgün gözükmesi için önerilen metodu uygulamanızı tavsiye ederim --> + +1. İlk nesne +1. İkinci nesne +1. Üçüncü nesne + +<!-- (Bunun çıktısı ile, sıralı olarak yazdığımız örneğin çıktısı aynı olacaktır) --> + +<!-- Ayrıca alt alta liste oluşturabilirsiniz --> + +1. İlk nesne +2. İkinci nesne +3. Üçüncü nesne + * Alt nesne + * Alt nesne +4. Dördüncü nesne + +<!-- Ayrıca görev listeleri de bulunmakta. HTML seçim kutusu(checkbox) oluşturacaktır. --> +Kutunun içerisinde `x` yoksa eğer seçim kutusu boş olacaktır. +- [ ] Yapılacak ilk görev. +- [ ] Yapılması gereken bir başka görev +Aşağıdaki seçim kutusu ise içi dolu olacaktır. +- [x] Bu görev başarıyla yapıldı + +<!-- Kod blokları --> +<!-- Kod bloklarını(<code> elementi) belirtmek için 4 adet boşluk veya bir +tab karakterini kullanabilirsiniz --> + + Bu bir kod + öyle mi? + +<!-- Ayrıca kod içerisinde girinti kullanmak istiyorsanız tekrar `tab` veya `4 boşluk` +kullanabilirsiniz --> + + my_array.each do |item| + puts item + end + +<!-- Yazı içerisinde kod belirtmek için sorgu tırnağı (`) kullanabilirsiniz --> + +Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor! + +<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz --> + +\`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` --> + +<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da +``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli +syntax aydınlatmaları uygulanacaktır --> + +<!-- Düz çizgi (<hr />) --> +<!-- Düz çizgiler 3 veya daha fazla yıldız/çizgi ile yapılabilir. Boşluklar önemsiz. --> + +*** +--- +- - - +**************** + +<!-- Linkler --> +<!-- Markdown'daki en güzel şeylerden biri kolayca link oluşturmaktır. +Linkte göstermek istediğiniz yazıyı [] içerisine yerleştirin ve sonuna parantezler içerisinde () +gideceği adresi belirtin --> + +[Bana tıkla!](http://test.com) + +<!-- Ayrıca linke `title` özelliği eklemek için tırnakları kullanabilirsiniz --> + +[Bana tıkla!](http://test.com "Test.com'a gider") + +<!-- Bağıl yollar da çalışıyor. --> +[Müzik dinle](/muzik/). + +<!-- Markdown ayrıca referans linklerini de destekler --> + +[Bu linke tıklayarak][link1] daha detaylı bilgi alabilirsiniz! +[Ayrıca bu linki de inceleyin][foobar] tabi istiyorsanız. + +[link1]: http://test.com/ "harika!" +[foobar]: http://foobar.biz/ "okey!" + +<!--Başlık ayrıca tek tırnak veya parantez içinde olabilir, veya direk yazılabilir. +Referans döküman içerisindeki herhangi bir yer olabilir ve referans IDsi +benzersiz olduğu sürece sorunsuz çalışacaktır. --> + +<!-- Ayrıca "dolaylı adlandırma" bulunmaktadır, "dolaylı adlandırma", linkin yazısının +aynı zamanda onun idsi olmasıdır --> + +[Bu][] bir link. +[bu]: http://bubirlink.com + +<!-- Fakat bu çok tercih edilen bir yöntem değil. --> + +<!-- Resimler --> +<!-- Resimler aslında linklere çok benziyor fakat başında ünlem bulunuyor! --> + + +<!-- Referanslar resimler için de geçerli --> +![Bu alt etiketi.][resmim] + +[resmim]: bagil/linkler/de/calisiyor.jpg "Başlık isterseniz buraya girebilirsiniz" + +<!-- Çeşitli --> +<!-- Oto-linkler --> + +<http://testwebsite.com/> ile +[http://testwebsite.com/](http://testwebsite.com) aynı şeyler + +<!-- Oto-linkler epostaları da destekler --> + +<foo@bar.com> + +<!-- Kaçış karakterleri --> + +Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmamasını istiyorum, +bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*. + +<!-- Tablolar --> +<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası +performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: --> + +| Sütun1 | Sütun 2 | Sütün 3 | +| :----------- | :------: | ------------: | +| Sola dayalı | Ortalı | Sağa dayalı | +| test | test | test | + +<!-- ayrıca, bunun aynısı --> + +Sütun 1 | Sütun 2 | Sütun 3 +:-- | :-: | --: +Çok çirkin göözüküyor | değil | mi? + +<!-- Bitiş! --> + +``` + +Daha detaylı bilgi için, John Gruber'in resmi söz dizimi yazısını [buradan](http://daringfireball.net/projects/markdown/syntax) veya Adam Pritchard'ın mükemmel hatırlatma kağıdını [buradan](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) inceleyebilirsiniz. diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown new file mode 100644 index 00000000..f27cbf08 --- /dev/null +++ b/tr-tr/objective-c-tr.html.markdown @@ -0,0 +1,320 @@ +--- +language: Objective-C +contributors: + - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] + - ["Yannick Loriot", "https://github.com/YannickL"] +filename: LearnObjectiveC-tr.m +translators: + - ["Haydar KULEKCI", "http://scanf.info/"] +lang: tr-tr +--- + +Objective-C Apple tarafından, OSX ve iOS işletim sistemleri ve onların +kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama dilidir. +Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C +programlama diline Smalltalk stilinde mesajlaşma ekler. + +```objective_c +// Tek satır yorum // işaretleri ile başlar + +/* +Çoklu satır yorum bu şekilde görünür. +*/ + +// #import ile Foundation başlıklarını projeye import edebiliriz. +#import <Foundation/Foundation.h> +#import "MyClass.h" + +// Progarmınızı girişi bir main fonksiyonudur ve bir integer değer döner. +int main (int argc, const char * argv[]) +{ + // Programdaki bellek kullanımını kontrol etmek için autorelease bir + // oluşturuyoruz. Autorelease bellekte kullanılmayan değerlerin kendi + // kendini silmesi demektir. + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + + // NSLog konsola bir satırlık bilgi yazdırmak için kullanılır. + NSLog(@"Hello World!"); // "Hello World!" değeri yazdırılır. + + /////////////////////////////////////// + // Tipler & Değişkenler + /////////////////////////////////////// + + // Basit Tanımlamalar + int myPrimitive1 = 1; + long myPrimitive2 = 234554664565; + + // Nesne Tanımlamaları + // strongly-typed nesne tanımlaması için karakter değişken isminin önüne + // * karakteri konulur. + MyClass *myObject1 = nil; // Strong typing + id myObject2 = nil; // Weak typing + // %@ bir nesnedir. + // 'description' objelerin değerlerinin gösterilmesi için bir düzendir. + NSLog(@"%@ and %@", myObject1, [myObject2 description]); + // "(null) and (null)" yazdırılacaktır. + + // Karakter Dizisi (String) + NSString *worldString = @"World"; + NSLog(@"Hello %@!", worldString); // "Hello World!" yazdırılacaktır. + + // Karakterler + NSNumber *theLetterZNumber = @'Z'; + char theLetterZ = [theLetterZNumber charValue]; + NSLog(@"%c", theLetterZ); + + // Tamsayılar + NSNumber *fortyTwoNumber = @42; + int fortyTwo = [fortyTwoNumber intValue]; + NSLog(@"%i", fortyTwo); + + NSNumber *fortyTwoUnsignedNumber = @42U; + unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42]; + short fortyTwoShort = [fortyTwoShortNumber shortValue]; + NSLog(@"%hi", fortyTwoShort); + + NSNumber *fortyTwoLongNumber = @42L; + long fortyTwoLong = [fortyTwoLongNumber longValue]; + NSLog(@"%li", fortyTwoLong); + + // Kayan Noktalı Sayılar (Floats) + NSNumber *piFloatNumber = @3.141592654F; + float piFloat = [piFloatNumber floatValue]; + NSLog(@"%f", piFloat); + + NSNumber *piDoubleNumber = @3.1415926535; + piDouble = [piDoubleNumber doubleValue]; + NSLog(@"%f", piDouble); + + // BOOL Değerler + NSNumber *yesNumber = @YES; + NSNumber *noNumber = @NO; + + // Dizi objeleri + NSArray *anArray = @[@1, @2, @3, @4]; + NSNumber *thirdNumber = anArray[2]; + NSLog(@"Third number = %@", thirdNumber); // "Third number = 3" yazdırılır + + // Dictionary objeleri + NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" }; + NSObject *valueObject = aDictionary[@"A Key"]; + NSLog(@"Object = %@", valueObject); // "Object = (null)" yazıdılır + + /////////////////////////////////////// + // Operatörler + /////////////////////////////////////// + + // Operatörler C dilindeki gibi çalışır. + // Örneğin: + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (NO) + 3 != 2; // => 1 (YES) + 1 && 1; // => 1 (Logical and) + 0 || 1; // => 1 (Logical or) + ~0x0F; // => 0xF0 (bitwise negation) + 0x0F & 0xF0; // => 0x00 (bitwise AND) + 0x01 << 1; // => 0x02 (bitwise left shift (by 1)) + + /////////////////////////////////////// + // Kontrol Yapıları + /////////////////////////////////////// + + // If-Else ifadesi + if (NO) + { + NSLog(@"I am never run"); + } else if (0) + { + NSLog(@"I am also never run"); + } else + { + NSLog(@"I print"); + } + + // Switch ifadesi + switch (2) + { + case 0: + { + NSLog(@"I am never run"); + } break; + case 1: + { + NSLog(@"I am also never run"); + } break; + default: + { + NSLog(@"I print"); + } break; + } + + // While döngü ifadesi + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++, ii değişkenini kullanıldıktan + //sonra yerinde artırır. + } // => "0," + // "1," + // "2," + // "3," yazdırılır + + // For döngü ifadesi + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj++); + } // => "0," + // "1," + // "2," + // "3," yazdırılır + + // Foreach ifadesi + NSArray *values = @[@0, @1, @2, @3]; + for (NSNumber *value in values) + { + NSLog(@"%@,", value); + } // => "0," + // "1," + // "2," + // "3," yazdırılır + + // Try-Catch-Finally ifadesi + @try + { + // İfadelerinizi buraya yazın + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"Sistemde Dosya Bulunamadı" userInfo:nil]; + } @catch (NSException * e) + { + NSLog(@"Exception: %@", e); + } @finally + { + NSLog(@"Finally"); + } // => "Exception: Sistemde Dosya Bulunamadı" + // "Finally" + // yazdırılacaktır + + /////////////////////////////////////// + // Objeler + /////////////////////////////////////// + + // Bellekten bir alan ayırmak ve objeyi burada oluşturmak bir obje örneği + // oluşturalım. Bir obje allocate ve init aşamalarını bitirmeden tam olarak + // işlevsel değildir. + MyClass *myObject = [[MyClass alloc] init]; + + // Objective-C nesne yönelimli programlama modelinin temelinde objelere + // mesaj gönderme vardır. + // Objective-C'de bir method çağırılmaz, ona bir mesaj gönderilir. + [myObject instanceMethodWithParameter:@"Steve Jobs"]; + + // Programda kullanılan bellek temizlenir + [pool drain]; + + // Program Sonu + return 0; +} + +/////////////////////////////////////// +// Sınıflar ve Fonksiyonlar +/////////////////////////////////////// + +// Sınıfınızı (MyClass.h) header dosyasında tanımlayın: + +// Sınıf tanımlama yapısı: +// @interface ClassName : ParentClassName <ImplementedProtocols> +// { +// Üye değişken (member variable) tanımlaması; +// } +// -/+ (type) Method tanımlaması; +// @end +@interface MyClass : NSObject <MyCustomProtocol> +{ + int count; + id data; + NSString *name; +} +// getter ve setter için otomatik oluşturulmuş gösterim. +@property int count; +@property (copy) NSString *name; // Copy the object during assignment. +@property (readonly) id data; // Declare only a getter method. + +// Metodlar ++/- (return type)methodSignature:(Parameter Type *)parameterName; + +// "+" class metodları içindir ++ (NSString *)classMethod; + +// "-" instance metodu içindir +- (NSString *)instanceMethodWithParmeter:(NSString *)string; +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number; + +@end + +// Metodların implementasyonlarını (MyClass.m) dosyasında yapıyoruz: + +@implementation UserObject + +// Obje bellekten silineceği (release) zaman çağırılır +- (void)dealloc +{ +} + +// Constructor'lar sınıf oluşturmanın bir yoludur +// Bu varsayılan bir constructor'dur ve bir obje oluşturulurken çağrılır. +- (id)init +{ + if ((self = [super init])) + { + self.count = 1; + } + return self; +} + ++ (NSString *)classMethod +{ + return [[self alloc] init]; +} + +- (NSString *)instanceMethodWithParmeter:(NSString *)string +{ + return @"New string"; +} + +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number +{ + return @42; +} + +// MyProtocol içerisinde metod tanımlamaları +- (void)myProtocolMethod +{ + // ifadeler +} + +@end + +/* + * Bir `protocol` herhangi bir sınıf tarafından implement edilen metodları tanımlar + * `Protocol`ler sınıfların kendileri değildir. Onlar basitçe diğer objelerin + * implementasyon için sorumlu oldukları bir arayüz (interface) tanımlarlar. + */ +@protocol MyProtocol + - (void)myProtocolMethod; +@end + + + +``` +## Daha Fazla Okuma + +[Vikipedi Objective-C](http://tr.wikipedia.org/wiki/Objective-C) + +[Objective-C Öğrenme](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/) + +[Lise Öğrencileri için iOS: Başlangıç](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started) diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown new file mode 100644 index 00000000..5258d785 --- /dev/null +++ b/tr-tr/php-tr.html.markdown @@ -0,0 +1,705 @@ +--- +language: PHP +filename: learnphp-tr.php +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +translators: + - ["Haydar KULEKCI", "http://scanf.info/"] +lang: tr-tr +--- + +PHP 5+ versiyonu için geçerlidir. + +```php +<?php // PHP kodları <?php etiketleri içerisinde bulunmalıdır. + +// Eğer php dosyanız sadece PHP kodu içeriyorsa, php'nin kapatma +// etiketini kapatmayabilirsiniz. + +// // işareti ile tek satırlık yorum satırı başlar. + +# # işareti de aynı görevi görür ancak // daha genel kullanımdadır. + + + +/* + Çoklu satır kodu bu şekilde yazıyoruz. slash yıldız ile başlar + ve yıldız slash ile biter. +*/ + +// "echo" ya da "print" metodları çıktı almak için kullanılır. +print('Hello '); // Ekrana Yeni satır karakteri olmadan "Hello " + // yazdırılır. + +// () parantezler "echo" ve "print" metodları için isteğe bağlıdır. +echo "World\n"; // Ekrana yeni satır karakteri olmadan "World" + // yazdırılır. +// (Bütün ifadeler noktalı virgül ile bitmelidir.) + +// <?php tagı dışarısındaki herşey otomatik olarak yazdırılacaktır. +?> +Hello World Again! +<?php + + +/************************************ +* Tipler ve Değişkenler +*************************************/ + +// Değişkenler $ sembolü ile başlar. +// Geçerli bir değişken bir harf veya alt çizgi ile başlar, +// devamında da bir sayı, harf veya alt çizgi ile devam eder. + +// Mantıksal değerler +// Boolean values are harf büyüklüğüne duyarsızdır. +$boolean = true; // veya TRUE veya True +$boolean = false; // veya FALSE veya False + +// Tam Sayılar +$int1 = 12; // => 12 +$int2 = -12; // => -12 +$int3 = 012; // => 10 (öneki 0 olan sekizlik(octal) bir sayıyı gösterir) +$int4 = 0x0F; // => 15 (öneki 0x olanlar hex sayıları gösterir.) + +// Kayan Noktalı Sayılar +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Değişken Silmek +unset($int1) + +// Aritmetik +$sum = 1 + 1; // 2 +$difference = 2 - 1; // 1 +$product = 2 * 2; // 4 +$quotient = 2 / 1; // 2 + +// Aritmetik Kısayolları +$number = 0; +$number += 1; // $number değişkeninin değerini 1 artırır. +echo $number++; // 1 yazdırılır. (Yazdırıldıktan sonra artırılır.) +echo ++$number; // 3 yazdırılır. (yazdırılmadan önce artırılır.) +$number /= $float; // Bölünür ve bölüm $number değerine eşitlenir. + +// Karakter dizileri(strings) tek tırnak ile kullanılmalıdır. +$sgl_quotes = '$String'; // => '$String' + +// Bir değişken içermediği sürece çift tırnak kullanmaktan kaçının +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' + +// Özel karakterler sadece çift tırnak ile kullanılabilir. +$escaped = "This contains a \t tab character."; +$unescaped = 'This just contains a slash and a t: \t'; + +// Gerekirse bir değişkeni küme ayracı içine alın. +$money = "I have $${number} in the bank."; + +// Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners +$nowdoc = <<<'END' +Multi line +string +END; + +// Heredocs will do string interpolation +$heredoc = <<<END +Multi line +$sgl_quotes +END; + +// . işareti ile karakter dizileri birbirine birleştirilebilir. +echo 'This string ' . 'is concatenated'; + + +/******************************** + * Sabitler + */ + +// Bir sabit define() metodu kullanılarak tanımlanır. +// ve çalışma zamanından hiçbir zaman değişmez! + +// geçerli bir sabit bir harf veya altçizgi ile başlar, +// ve bir sayı, harf ya da altçizgi ile devam eder. +define("FOO", "something"); + +// sabite ulaşmak için direk olarak seçilen ismi kullanabilirsiniz. +echo 'This outputs '.FOO; + + +/******************************** + * Diziler + */ + +// PHP'de bütün diziler ilişikilendirilebilirdir. (hashmaps), +// İlişkilendirilebilir(associative) diziler, hashmap olarak bilinir. + +// PHP'nin bütün versiyonları için çalışır +$associative = array('One' => 1, 'Two' => 2, 'Three' => 3); + +// PHP 5.4 ile yeni bir söz dizimi kullanılmaya başlandı +$associative = ['One' => 1, 'Two' => 2, 'Three' => 3]; + +echo $associative['One']; // 1 yazdıracaktır. + +// Liste kullanımında index'ler tam sayıdır. +$array = ['One', 'Two', 'Three']; +echo $array[0]; // => "One" + +// Dizinin sonuna bir eleman ekleme +$array[] = 'Four'; + +// Diziden eleman silme +unset($array[3]); + +/******************************** + * Çıktı + */ + +echo('Hello World!'); +// Hello World! çıktısı stdout'a yazdırılır. +// Eğer bir web browser ile çalışıyorsanır Stdout bir web sayfasıdır. + +print('Hello World!'); // echo ile aynıdır. + +// Aslında echo bir dil sabitidir, parantezleri kullanmayabilirsiniz. +echo 'Hello World!'; +print 'Hello World!'; // Bu yazdırılacaktır. + +$paragraph = 'paragraph'; + +echo 100; // Echo ile doğrudan sayısal değer kullanımı +echo $paragraph; // veya değişken + +// PHP 5.4.0 veya daha üstü sürümlerde kısa açılış etiketi +// konfigürasyonları yapıldı ise, kısa açılış etiketini kullanabilirsiniz. +?> +<p><?= $paragraph ?></p> +<?php + +$x = 1; +$y = 2; +$x = $y; // Şu anda $x değişkeni $y ile aynı değere sahiptir. +$z = &$y; +// $z, $y'nin referansını içermektedir. +// $z'nin değerinin değişmesi $y'nin değerinide değiştireceltir veya +// tam tersi. Ancak $x özgün değeri olarak kalacaktır. + +echo $x; // => 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 + +// Dump'lar değişkenin tipi ve değerini yazdırır +var_dump($z); // int(0) yazdırılacaktır + +// Print'ler ise değişkeni okunabilir bir formatta yazdıracaktır. +print_r($array); // Çıktı: Array ( [0] => One [1] => Two [2] => Three ) + + +/******************************** + * Mantık + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; + +// Argüman doğru değilse bir hata fırlatılacaktır. + +// Bu karşılaştırmalar tipler aynı olmasa bile her zaman true olacaktır. +assert($a == $b); // equality +assert($c != $a); // inequality +assert($c <> $a); // alternative inequality +assert($a < $c); +assert($c > $b); +assert($a <= $b); +assert($c >= $d); + +// Aşağıdakiler yanlızca değer ve tip aynı olduğunda true olacaktır. +assert($c === $d); +assert($a !== $d); +assert(1 == '1'); +assert(1 !== '1'); + +// Değişkenler kullanıma bağlı olarak farklı tiplere çevrilebilir. + +$integer = 1; +echo $integer + $integer; // => 2 + +$string = '1'; +echo $string + $string; // => 2 (Karakter dizisi tam sayıya çevrilmeye zorlanır) + +$string = 'one'; +echo $string + $string; // => 0 +// Çıktı 0 olacaktır, çünkü + operatörü karakter dizisi olan 'one' değerini +// bir sayıya çeviremez. + +// Veri tipi çevirileri bir değişkeni farklı bir türde +// düzenlemek için kullanılabilir. + +$boolean = (boolean) 1; // => true + +$zero = 0; +$boolean = (boolean) $zero; // => false + +// Veri tiplerini çevirmek için bazı fonksiyonlar vardır. +$integer = 5; +$string = strval($integer); + +$var = null; // Null değeri. + + +/******************************** + * Kontrol Yapıları + */ + +if (true) { + print 'I get printed'; +} + +if (false) { + print 'I don\'t'; +} else { + print 'I get printed'; +} + +if (false) { + print 'Does not get printed'; +} elseif(true) { + print 'Does'; +} + +// Üçlü operatör +print (false ? 'Does not get printed' : 'Does'); + +$x = 0; +if ($x === '0') { + print 'Does not print'; +} elseif($x == '1') { + print 'Does not print'; +} else { + print 'Does print'; +} + + + +// Bu alternatif sözdizimi template'ler için kullanışlıdır. +?> + +<?php if ($x): ?> +This is displayed if the test is truthy. +<?php else: ?> +This is displayed otherwise. +<?php endif; ?> + +<?php + +// Use switch to save some logic. +switch ($x) { + case '0': + print 'Switch does type coercion'; + break; // Bir breake yazmalısınız ya da 'two' ve 'three' + // durumunuda kapsarsınız. + case 'two': + case 'three': + // $variable değişkeni 'two' ya da 'three' ise + break; + default: + // Varsayılan olarak bir şey yap +} + +// While, do...while ve for döngüleri tanıdıktır. +$i = 0; +while ($i < 5) { + echo $i++; +}; // "01234" yazdırılacaktır + +echo "\n"; + +$i = 0; +do { + echo $i++; +} while ($i < 5); // "01234" yazdırılacaktır. + +echo "\n"; + +for ($x = 0; $x < 10; $x++) { + echo $x; +} // "0123456789" yazdırılacaktır. + +echo "\n"; + +$wheels = ['bicycle' => 2, 'car' => 4]; + +// Foreach döngüsü diziler üzerinde çalışır +foreach ($wheels as $wheel_count) { + echo $wheel_count; +} // "24" yazdırılacaktır. + +echo "\n"; + +// Key-Value değerlere ulaşabilirsiniz. +foreach ($wheels as $vehicle => $wheel_count) { + echo "A $vehicle has $wheel_count wheels"; +} + +echo "\n"; + +$i = 0; +while ($i < 5) { + if ($i === 3) { + break; // while döngüsünden çıkar + } + echo $i++; +} // Prints "012" + +for ($i = 0; $i < 5; $i++) { + if ($i === 3) { + continue; // Aktif döngüyü atlar + } + echo $i; +} // "0124" yazdırılacaktır. + + + +/******************************** + * Fonksiyonlar + */ + +// Bir fonksiyon tanımlamak için "function" kullanılır: +function my_function () { + return 'Hello'; +} + +echo my_function(); // => "Hello" + +// Geçerli bir fonksiyon ismi bir harf veya altçizgi ile başlar ve +// bir sayı, harf ya da alt çizgi ile devam eder. + +function add ($x, $y = 1) { // $y değeri isteğe bağlıdır ve + // varsayılan değeri 1'dir + $result = $x + $y; + return $result; +} + +echo add(4); // => 5 +echo add(4, 2); // => 6 + +// $result fonksiyon dışında ulaşılabilir değildir. +// print $result; // Bir uyarı verecektir. + +// PHP 5.3'den beri bir anonymous fonksiyon tanımlayabilirsiniz; +$inc = function ($x) { + return $x + 1; +}; + +echo $inc(2); // => 3 + +function foo ($x, $y, $z) { + echo "$x - $y - $z"; +} + +// Fonksiyonlar bir fonksiyon dönebilir. +function bar ($x, $y) { + // Fonksiyona dışardan değişken gönderebilmek için 'use' komutunu kullanın. + return function ($z) use ($x, $y) { + foo($x, $y, $z); + }; +} + +$bar = bar('A', 'B'); +$bar('C'); // "A - B - C" yazdırılacaktır. + +// Fonksiyonun ismini karakter dizinden çağırabilirsiniz. +$function_name = 'add'; +echo $function_name(1, 2); // => 3 +// Programatik olarak fonksiyonları çalıştırmak için yararlı olabilir +// veya, call_user_func(callable $callback [, $parameter [, ... ]]); kulanın. + + +/******************************** + * Includes + */ + +<?php +// PHP'de include edilecek dosyalar PHP açma etiketi ile başlamalı. (!) + +include 'my-file.php'; +// my-file.php dosyasındaki kodlar artık mevcut scope'da kullanılabilir. +// Eğer dosya include edilemezse bir uyarı (örneğin: file not found) +// fırlatılacaktır. + +include_once 'my-file.php'; +// Eğer bir dosya include edildi ise tekrar include edilmeyecektir. +// Bu çoklu class tanımlama hatalarını önler. + +require 'my-file.php'; +require_once 'my-file.php'; +// Dosya include edilemediğinde fatal error veren require() bu konu +// dışında include() ile aynıdır. + +// my-include.php dosyasının içeriği: +<?php + +return 'Anything you like.'; +// Dosya sonu + +// Include'lar ver require'lar aynı zamanda bir return dönebilir. +$value = include 'my-include.php'; + +// Dosyalar verilen dosya yoluna göre include edilir veya, hiçbirşey +// verilmezse include_path konfigürasyonuna göre include edecektir. +// Eğer dosya include_path'da da bulunamazsa include hata vermeden +// önce içinde bulunulan dizini kontrol ecektir. +/* */ + + +/******************************** + * Sınıflar + */ + +// Sınıflar class kelimesi ile tanımlanır + +class MyClass +{ + const MY_CONST = 'value'; // Bir sabit + + static $staticVar = 'static'; + + // Static değişkenler ve onların görünürlüğü + public static $publicStaticVar = 'publicStatic'; + private static $privateStaticVar = 'privateStatic'; + // Sadece bu sınıf içerisinde erişilebilir + protected static $protectedStaticVar = 'protectedStatic'; + // Bu sınıf ve alt sınıflarından erişilebilir + + // Özellikler görünürlüğü ile birlikte tanımlanmalıdır. + public $property = 'public'; + public $instanceProp; + protected $prot = 'protected'; // Sınıf ve alt sınıflardan erişilebilir + private $priv = 'private'; // Sadece bu sınıftan erişilebilir + + // __construct ile bir constructor oluşturulabilir. + public function __construct($instanceProp) { + // $this ile instance değişkenine erişilir. + $this->instanceProp = $instanceProp; + } + + // Sınıfın içerisinde metodlar fonksiyonlar gibi tanımlanır. + public function myMethod() + { + print 'MyClass'; + } + + //final anahtar kelimesi bu metodu override edilemez yapacaktır. + final function youCannotOverrideMe() + { + } + +/* +Bir sınıfın özelliğini ya da metodunu statik yaptığınız takdirde sınıfın bir +objesini oluşturmadan bu elemana erişebilirsiniz. Bir özellik statik tanımlanmış +ise obje üzerinden bu elemana erişilemez. (Statik metodlar öyle değildir.) +*/ + + + public static function myStaticMethod() + { + print 'I am static'; + } +} + +echo MyClass::MY_CONST; // 'value' şeklinde çıktı verir; +echo MyClass::$staticVar; // 'static' şeklinde çıktı verir; +MyClass::myStaticMethod(); // 'I am static' şeklinde çıktı verir; + +// Sınıfların new ile kullanımı +$my_class = new MyClass('An instance property'); +// Eğer argüman göndermeyeceksek parantezler isteğe bağlıdır. + +// Sınıfın üyelerine erişim -> +echo $my_class->property; // => "public" +echo $my_class->instanceProp; // => "An instance property" +$my_class->myMethod(); // => "MyClass" + + +// "extends" ile sınıfı extend etmek +class MyOtherClass extends MyClass +{ + function printProtectedProperty() + { + echo $this->prot; + } + + // Bir methodu ezmek + function myMethod() + { + parent::myMethod(); + print ' > MyOtherClass'; + } +} + +$my_other_class = new MyOtherClass('Instance prop'); +$my_other_class->printProtectedProperty(); // "protected" şeklinde çıktı verir. +$my_other_class->myMethod(); // "MyClass > MyOtherClass" şeklinde çıktı verir + +final class YouCannotExtendMe +{ +} + +// getter ve setter'ları oluşturmak için "magic method"ları kullanabilirsiniz. +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; // __get() metodunu kullanacaktır. +$x->property = 'Something'; // __set() metodunu kullanacaktır. + +// Sınıflar abstract olabilir(abstract kelimesini kullanarak) veya +// interface'ler uygulanabilir (implements kelimesi kullanılarak). +// Bir interface "interface" kelimesi kullanılarak oluşturulur. + +interface InterfaceOne +{ + public function doSomething(); +} + +interface InterfaceTwo +{ + public function doSomethingElse(); +} + +// interfaces can be extended +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'; + } +} + + +// Sınıflar birden fazla interface kullanabilir. +class SomeOtherClass implements InterfaceOne, InterfaceTwo +{ + public function doSomething() + { + echo 'doSomething'; + } + + public function doSomethingElse() + { + echo 'doSomethingElse'; + } +} + + + +/******************************** + * Traits + */ +// Trait'ler PHP 5.4.0'dan beri kullanılabilir ve "trait" kullanılarak +// tanımlanır. + +trait MyTrait +{ + public function myTraitMethod() + { + print 'I have MyTrait'; + } +} + +class MyTraitfulClass +{ + use MyTrait; +} + +$cls = new MyTraitfulClass(); +$cls->myTraitMethod(); // "I have MyTrait" çıktısını verir. + + + +/******************************** + * İsim Uzayları + */ + +// Bu alan ayrılmıştır, çünkü isim uzayı tanımı bir dosyada en başta +// yapılmalıdır. Bu örnekte böyle olmadığını varsayalım. + +<?php + +// Varsayılan olarak, sınıflar global isim uzayındadır, ve açıkça bir +// ters slash ile çağrılabilir. + +$cls = new \MyClass(); + + + +// Bir dosya için isim uzayı atama +namespace My\Namespace; + +class MyClass +{ +} + +// (diğer bir dosya) +$cls = new My\Namespace\MyClass; + +//veya diğer bir isim uzayında. +namespace My\Other\Namespace; + +use My\Namespace\MyClass; + +$cls = new MyClass(); + +// veya isim uzayına bir takma isim koyabilirsiniz. + +namespace My\Other\Namespace; + +use My\Namespace as SomeOtherNamespace; + +$cls = new SomeOtherNamespace\MyClass(); + +*/ + +``` + +## Daha fazla bilgi + +Referans ve topluluk yazıları için [official PHP documentation](http://www.php.net/manual/) adresini ziyaret edin. + +Güncel en yi örnekler için [PHP Usulüne Uygun](http://kulekci.net/php-the-right-way/) adresini ziyaret edin. + +Eğer bir paket yöneticisi olan dil kullandıysanız, [Composer](http://getcomposer.org/)'a bir göz atın. + +Genel standartlar için PHP Framework Interoperability Group'unun [PSR standards](https://github.com/php-fig/fig-standards) ziyaret edebilirsiniz. + diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown new file mode 100644 index 00000000..01285080 --- /dev/null +++ b/tr-tr/python-tr.html.markdown @@ -0,0 +1,502 @@ +--- +language: python +filename: learnpython-tr.py +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Haydar KULEKCI", "http://scanf.info/"] +lang: tr-tr +--- +Python Guido Van Rossum tarafından 90'ların başında yaratılmıştır. Şu anda +varolanlar arasında en iyi dillerden birisidir. Ben (Louie Dinh) Python +dilinin syntax'ının belirginliğine aşığım. O basit olarak çalıştırılabilir +pseudocode'dur. + +Geri bildirimlerden son derece mutluluk duyarım! Bana [@louiedinh](http://twitter.com/louiedinh) +adresinden ya da louiedinh [at] [google's email service] adresinden ulaşabilirsiniz. + +Çeviri için geri bildirimleri de [@kulekci](http://twitter.com/kulekci) +adresine yapabilirsiniz. + +Not: Bu yazıdaki özellikler Python 2.7 için geçerlidir, ama Python 2.x için de +uygulanabilir. Python 3 için başka bir zaman tekrar bakınız. + + +```python +# Tek satır yorum hash işareti ile başlar. +""" Çoklu satır diziler üç tane çift tırnak + arasında yazılır. Ve yorum olarak da + kullanılabilir +""" + + +#################################################### +## 1. İlkel Veri Tipleri ve Operatörler +#################################################### + +# Sayılar +3 #=> 3 + +# Matematik beklediğiniz gibi +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız +# sonuç otomatik olarak kırpılır. +5 / 2 #=> 2 + +# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir. +2.0 # Bu bir kayan noktalı sayı +11.0 / 4.0 #=> 2.75 ahhh...daha iyi + +# İşlem önceliğini parantezler ile sağlayabilirsiniz. +(1 + 3) * 2 #=> 8 + +# Boolean değerleri bilindiği gibi +True +False + +# not ile nagatif(mantıksal) değerini alma +not True #=> False +not False #=> True + +# Eşitlik == +1 == 1 #=> True +2 == 1 #=> False + +# Eşitsizlik != +1 != 1 #=> False +2 != 1 #=> True + +# Daha fazla karşılaştırma +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Karşılaştırma zincirleme yapılabilir! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Karakter dizisi " veya ' ile oluşturulabilir +"This is a string." +'This is also a string.' + +# Karakter dizileri birbirleri ile eklenebilir +"Hello " + "world!" #=> "Hello world!" + +# A string can be treated like a list of characters +# Bir string'e karakter listesi gibi davranabilirsiniz. +"This is a string"[0] #=> 'T' + +# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi: +"%s can be %s" % ("strings", "interpolated") + +# String'leri formatlamanın yeni bir yöntem ise format metodudur. +# Bu metod tercih edilen yöntemdir. +"{0} can be {1}".format("strings", "formatted") +# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz. +"{name} wants to eat {food}".format(name="Bob", food="lasagna") + +# None bir objedir +None #=> None + +# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın. +# Onun yerine "is" kullanın. +"etc" is None #=> False +None is None #=> True + +# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler +# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır. + +# None, 0 ve boş string/list'ler False olarak değerlendirilir. +# Tüm eşitlikler True döner +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Değişkenler ve Kolleksiyonlar +#################################################### + +# Ekrana yazdırma oldukça kolaydır. +print "I'm Python. Nice to meet you!" + + +# Değişkenlere bir değer atamadan önce tanımlamaya gerek yoktur. +some_var = 5 # Değişken isimlerinde gelenek küçük karakter ve alt çizgi + # kullanmaktır. +some_var #=> 5 + +# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye +# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla +# bilgi için kontrol akışı kısmına göz atınız. +some_other_var # isim hatası fırlatılır + +# isterseniz "if"i bir ifade gibi kullanabilirsiniz. +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listeler +li = [] +# Önceden değerleri tanımlanmış listeler +other_li = [4, 5, 6] + +# Bir listenin sonuna birşeyler eklemek +li.append(1) #li şu anda [1] +li.append(2) #li şu anda [1, 2] +li.append(4) #li şu anda [1, 2, 4] +li.append(3) #li şu anda [1, 2, 4, 3] +# pop ile sondan birşeyler silmek +li.pop() #=> 3 and li is now [1, 2, 4] +# Tekrar sonuna eklemek +li.append(3) # li is now [1, 2, 4, 3] again. + +# Dizi gibi listenin elemanlarına erişmek +li[0] #=> 1 +# Son elemanın değerine ulaşmak +li[-1] #=> 3 + +# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası +# fırlatılır +li[4] # IndexError fırlatılır + +# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz. +# (Açık ve kapalı aralıklıdır.) +li[1:3] #=> [2, 4] +# Başlangıcı ihmal etme +li[2:] #=> [4, 3] +# Sonu ihmal etme +li[:3] #=> [1, 2, 4] + +# "del" ile istenilen bir elemanı listeden silmek +del li[2] # li is now [1, 2, 3] + +# Listeleri birbiri ile birleştirebilirsiniz. +li + other_li #=> [1, 2, 3, 4, 5, 6] - Not: li ve other_li yanlız bırakılır + +# extend ile listeleri birleştirmek +li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] + +# bir değerin liste içerisinde varlığını "in" ile kontrol etmek +1 in li #=> True + +# "len" ile listenin uzunluğunu bulmak +len(li) #=> 6 + +# Tüpler listeler gibidir sadece değişmezler(immutable) +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # TypeError fırlatılır. + +# Litelerde yapılanların hepsini tüplerde de yapılabilir +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere +# atanabilir +a, b, c = (1, 2, 3) # a şu anda 1, b şu anda 2 ve c şu anda 3 +# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur +d, e, f = 4, 5, 6 +# şimdi iki değeri değiş tokuş etmek çok kolaydır. +e, d = d, e # d şimdi 5 ve e şimdi 4 + + +# Sözlükler (Dictionaries) key-value saklanır. +empty_dict = {} +# Sözlüklere önceden değer atama örneği +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Değere ulaşmak için [] kullanılır +filled_dict["one"] #=> 1 + +# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır +filled_dict.keys() #=> ["three", "two", "one"] +# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir +# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir + +# Tüm değerleri almak için "values()" kullanabilirsiniz. +filled_dict.values() #=> [3, 2, 1] +# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir. + +# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Olmayan bir anahtar çağrıldığında KeyError fırlatılır. +filled_dict["four"] # KeyError + +# "get()" metodu KeyError fırlatılmasını önler +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama +# imknaı sağlar. +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# "setdefault()" metodu sözlüğe yeni bir key-value eşleşmesi eklemenin +# güvenli bir yoludur. +filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5 +filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5 + + +# Sets store ... well sets +empty_set = set() +# Bir demek değer ile bir "set" oluşturmak +some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4]) + +# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Bir set'e daha fazla eleman eklemek +filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} + +# "&" işareti ile iki set'in kesişimlerini alınabilir +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# | işareti ile +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# "-" işareti ile iki set'in farkları alınabilir +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Akış Denetimi +#################################################### + +# Bir değişken oluşturmak +some_var = 5 + +# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir! +# "some_var is smaller than 10" yazdırılır. +if some_var > 10: + print "some_var is totally bigger than 10." +elif some_var < 10: # elif ifadesi isteğe bağlıdır + print "some_var is smaller than 10." +else: # Bu da isteğe bağlıdır. + print "some_var is indeed 10." + + +""" +For döngüleri listeler üzerinde iterasyon yapar +Ekrana yazdırılan: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz + print "%s is a mammal" % animal + +""" +"range(number)" ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner +Ekrana yazdırılan: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +While döngüsü koşul sağlanmayana kadar devam eder +Ekrana yazdırılan: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Shorthand for x = x + 1 + +# try/except bloğu ile hatalar ayıklanabilir + +# Python 2.6 ve üstü için çalışacaktır: +try: + # "raise" bir hata fırlatmak için kullanılabilir + raise IndexError("This is an index error") +except IndexError as e: + pass # Pass is just a no-op. Usually you would do recovery here. + + +#################################################### +## 4. Fonksiyonlar +#################################################### + + +# Yeni bir fonksiyon oluşturmak için "def" kullanılır +def add(x, y): + print "x is %s and y is %s" % (x, y) + return x + y # Return values with a return statement + +# Fonksiyonu parametre ile çağırmak +add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11 + +# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak +add(y=6, x=5) # Anahtar argümanlarının sırası farklı da olabilir + +# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + +# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da +# tanımlayabilirsiniz. +def keyword_args(**kwargs): + return kwargs + +# Şu şekilde kullanılacaktır +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Eğer isterseniz ikisini aynı anda da yapabilirsiniz +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) prints: + (1, 2) + {"a": 3, "b": 4} +""" + +# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz! +# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # foo(1, 2, 3, 4) ile eşit +all_the_args(**kwargs) # foo(a=3, b=4) ile eşit +all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit + +# Python first-class fonksiyonlara sahiptir +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Anonymous fonksiyonlar da vardır +(lambda x: x > 2)(3) #=> True + +# Dahili yüksek seviye fonksiyonlar vardır +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + + +#################################################### +## 5. Sınıflar +#################################################### + +# We subclass from object to get a class. +class Human(object): + + # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır. + species = "H. sapiens" + + # Basic initializer + def __init__(self, name): + # Metoda gelen argümanın değerini sınıfın elemanı olan "name" + # değişkenine atama + self.name = name + + # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" + # parametresini alır + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Bir sınıf metodu tüm "instance"lar arasında paylaşılır + # İlk argüman olarak sınıfı çağırarak çağrılırlar + @classmethod + def get_species(cls): + return cls.species + + # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır + @staticmethod + def grunt(): + return "*grunt*" + + +# Bir sınıf örneği oluşturmak +i = Human(name="Ian") +print i.say("hi") # "Ian: hi" çıktısı verir + +j = Human("Joel") +print j.say("hello") # "Joel: hello" çıktısı verir + +# Sınıf metodunu çağıralım +i.get_species() #=> "H. sapiens" + +# Paylaşılan sınıf özellik değiştirelim. +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Statik metodu çağırma +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Modüller +#################################################### + +# Modülleri sayfaya dahil edebilirsiniz +import math +print math.sqrt(16) #=> 4 + +# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Modüldeki tüm fonksiyonları dahil edebilirsiniz +# Uyarı: bu önerilmez +from math import * + +# Modülün adını kısaltabilirsiniz +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül +# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı +# aynı olmalıdır. + +# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz. +import math +dir(math) + + + +``` + +## Daha fazlası için hazır mısınız? + +### Ücretsiz Dökümanlar + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Dead Tree + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown new file mode 100644 index 00000000..2477c5da --- /dev/null +++ b/tr-tr/python3-tr.html.markdown @@ -0,0 +1,635 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] + - ["Steven Basart", "http://github.com/xksteven"] + - ["Andre Polykanine", "https://github.com/Oire"] + - ["Andre Polykanine", "https://github.com/Oire"] +translators: + - ["Eray AYDIN", "http://erayaydin.me/"] +lang: tr-tr +filename: learnpython3-tr.py +--- + +Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur. + +Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/python/) kontrol edebilirsiniz. + +```python + +# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır. + +""" Çok satırlı olmasını istediğiniz yorumlar + üç adet tırnak(") işareti ile + yapılmaktadır +""" + +#################################################### +## 1. Temel Veri Türleri ve Operatörler +#################################################### + +# Sayılar +3 # => 3 + +# Tahmin edebileceğiniz gibi matematik +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 + +# Bölme işlemi varsayılan olarak onluk döndürür +35 / 5 # => 7.0 + +# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Onluk kullanırsanız, sonuç da onluk olur +3 * 2.0 # => 6.0 + +# Kalan operatörü +7 % 3 # => 1 + +# Üs (2 üzeri 4) +2**4 # => 16 + +# Parantez ile önceliği değiştirebilirsiniz +(1 + 3) * 2 # => 8 + +# Boolean(Doğru-Yanlış) değerleri standart +True +False + +# 'değil' ile terse çevirme +not True # => False +not False # => True + +# Boolean Operatörleri +# "and" ve "or" büyük küçük harf duyarlıdır +True and False #=> False +False or True #=> True + +# Bool operatörleri ile sayı kullanımı +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Eşitlik kontrolü == +1 == 1 # => True +2 == 1 # => False + +# Eşitsizlik Kontrolü != +1 != 1 # => False +2 != 1 # => True + +# Diğer karşılaştırmalar +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Zincirleme şeklinde karşılaştırma da yapabilirsiniz! +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir +"Bu bir yazı." +'Bu da bir yazı.' + +# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem. +"Merhaba " + "dünya!" # => "Merhaba dünya!" + +# Bir yazı(string) karakter listesi gibi işlenebilir +"Bu bir yazı"[0] # => 'B' + +# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde: +"{} da ayrıca {}".format("yazılar", "işlenebilir") + +# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz. +"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu") +#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir" + +# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz. +"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor" + +# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız, +# eski stil formatlamayı kullanabilirsiniz: +"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir") + + +# Hiçbir şey(none) da bir objedir +None # => None + +# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın +# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir. +"vb" is None # => False +None is None # => True + +# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü. +# Diğer veriler ise True değeri döndürür +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. Değişkenler ve Koleksiyonlar +#################################################### + +# Python bir yazdırma fonksiyonuna sahip +print("Ben Python. Tanıştığıma memnun oldum!") + +# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok. +# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin +bir_degisken = 5 +bir_degisken # => 5 + +# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır. +# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz. +bir_bilinmeyen_degisken # NameError hatası oluşturur + +# Listeler ile sıralamaları tutabilirsiniz +li = [] +# Önceden doldurulmuş listeler ile başlayabilirsiniz +diger_li = [4, 5, 6] + +# 'append' ile listenin sonuna ekleme yapabilirsiniz +li.append(1) # li artık [1] oldu +li.append(2) # li artık [1, 2] oldu +li.append(4) # li artık [1, 2, 4] oldu +li.append(3) # li artık [1, 2, 4, 3] oldu +# 'pop' ile listenin son elementini kaldırabilirsiniz +li.pop() # => 3 ve li artık [1, 2, 4] +# Çıkarttığımız tekrardan ekleyelim +li.append(3) # li yeniden [1, 2, 4, 3] oldu. + +# Dizi gibi listeye erişim sağlayın +li[0] # => 1 +# Son elemente bakın +li[-1] # => 3 + +# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur +li[4] # IndexError hatası oluşturur + +# Bir kısmını almak isterseniz. +li[1:3] # => [2, 4] +# Başlangıç belirtmezseniz +li[2:] # => [4, 3] +# Sonu belirtmesseniz +li[:3] # => [1, 2, 4] +# Her ikişer objeyi seçme +li[::2] # =>[1, 4] +# Listeyi tersten almak +li[::-1] # => [3, 4, 2, 1] +# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz +# li[baslangic:son:adim] + +# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz +del li[2] # li artık [1, 2, 3] oldu + +# Listelerde de ekleme yapabilirsiniz +# Not: değerler üzerinde değişiklik yapılmaz. +li + diger_li # => [1, 2, 3, 4, 5, 6] + +# Listeleri birbirine bağlamak için "extend()" kullanılabilir +li.extend(diger_li) # li artık [1, 2, 3, 4, 5, 6] oldu + +# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir +1 in li # => True + +# Uzunluğu öğrenmek için "len()" kullanılabilir +len(li) # => 6 + + +# Tüpler listeler gibidir fakat değiştirilemez. +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # TypeError hatası oluşturur + +# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# Tüpleri(veya listeleri) değişkenlere açabilirsiniz +a, b, c = (1, 2, 3) # 'a' artık 1, 'b' artık 2 ve 'c' artık 3 +# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur +d, e, f = 4, 5, 6 +# 2 değeri birbirine değiştirmek bu kadar kolay +e, d = d, e # 'd' artık 5 ve 'e' artık 4 + + +# Sözlükler anahtar kodlarla verileri tutar +bos_sozl = {} +# Önceden doldurulmuş sözlük oluşturma +dolu_sozl = {"bir": 1, "iki": 2, "uc": 3} + +# Değere bakmak için [] kullanalım +dolu_sozl["bir"] # => 1 + +# Bütün anahtarları almak için "keys()" kullanılabilir. +# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz. +# Not - Sözlük anahtarlarının sıralaması kesin değildir. +# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir. +list(dolu_sozl.keys()) # => ["uc", "iki", "bir"] + + +# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor +# Not - Sıralama değişebilir. +list(dolu_sozl.values()) # => [3, 2, 1] + + +# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz +"bir" in dolu_sozl # => True +1 in dolu_sozl # => False + +# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır. +dolu_sozl["dort"] # KeyError hatası oluşturur + +# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz +dolu_sozl.get("bir") # => 1 +dolu_sozl.get("dort") # => None +# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz. +dolu_sozl.get("bir", 4) # => 1 +dolu_sozl.get("dort", 4) # => 4 + +# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır +dolu_sozl.setdefault("bes", 5) # dolu_sozl["bes"] artık 5 değerine sahip +dolu_sozl.setdefault("bes", 6) # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip + +# Sözlüğe ekleme +dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4} +#dolu_sozl["dort"] = 4 #sözlüğe eklemenin bir diğer yolu + +# Sözlükten anahtar silmek için 'del' kullanılabilir +del dolu_sozl["bir"] # "bir" anahtarını dolu sözlükten silecektir + + +# Setler ... set işte :D +bos_set = set() +# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm. +bir_set = {1, 1, 2, 2, 3, 4} # bir_set artık {1, 2, 3, 4} + +# Sete yeni setler ekleyebilirsiniz +dolu_set = bir_set + +# Sete bir diğer öğe ekleme +dolu_set.add(5) # dolu_set artık {1, 2, 3, 4, 5} oldu + +# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz +diger_set = {3, 4, 5, 6} +dolu_set & diger_set # => {3, 4, 5} + +# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz +dolu_set | diger_set # => {1, 2, 3, 4, 5, 6} + +# Farklılıkları almak için "-" kullanabilirsiniz +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir +2 in dolu_set # => True +10 in dolu_set # => False + + +#################################################### +## 3. Kontrol Akışları ve Temel Soyutlandırma +#################################################### + +# Bir değişken oluşturalım +bir_degisken = 5 + +# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir! +# çıktı olarak "bir_degisken 10 dan küçük" yazar +if bir_degisken > 10: + print("bir_degisken 10 dan büyük") +elif bir_degisken < 10: # Bu 'elif' ifadesi zorunlu değildir. + print("bir_degisken 10 dan küçük") +else: # Bu ifade de zorunlu değil. + print("bir_degisken değeri 10") + + +""" +Döngülerle lsiteleri döngüye alabilirsiniz +çıktı: + köpek bir memeli hayvandır + kedi bir memeli hayvandır + fare bir memeli hayvandır +""" +for hayvan in ["köpek", "kedi, "fare"]: + # format ile kolayca yazıyı biçimlendirelim + print("{} bir memeli hayvandır".format(hayvan)) + +""" +"range(sayi)" bir sayı listesi döndür +0'dan belirttiğiniz sayıyıa kadar +çıktı: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir. +çıktı: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Uzun hali x = x + 1 + +# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz +try: + # Bir hata oluşturmak için "raise" kullanabilirsiniz + raise IndexError("Bu bir index hatası") +except IndexError as e: + pass # Önemsiz, devam et. +except (TypeError, NameError): + pass # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse. +else: # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır + print("Her şey iyi!") # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı + +# Temel Soyutlandırma, bir objenin işlenmiş halidir. +# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi. + +dolu_sozl = {"bir": 1, "iki": 2, "uc": 3} +temel_soyut = dolu_sozl.keys() +print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu + +# Temel Soyutlandırılmış objeyi döngüye sokabiliriz. +for i in temel_soyut: + print(i) # Çıktısı: bir, iki, uc + +# Fakat, elementin anahtarına değerine. +temel_soyut[1] # TypeError hatası! + +# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır. +iterator = iter(temel_soyut) + +# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır +# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz. +iterator.__next__() #=> "bir" + +# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir +iterator.__next__() #=> "iki" +iterator.__next__() #=> "uc" + +# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır. +iterator.__next__() # StopIteration hatası + +# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz. +list(dolu_sozl.keys()) #=> Returns ["bir", "iki", "uc"] + + +#################################################### +## 4. Fonksiyonlar +#################################################### + +# "def" ile yeni fonksiyonlar oluşturabilirsiniz +def topla(x, y): + print("x = {} ve y = {}".format(x, y)) + return x + y # Değer döndürmek için 'return' kullanmalısınız + +# Fonksiyonu parametleri ile çağırıyoruz +topla(5, 6) # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür + +# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek +topla(y=6, x=5) # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz. + +# Sınırsız sayıda argüman da alabilirsiniz +def argumanlar(*argumanlar): + return argumanlar + +argumanlar(1, 2, 3) # => (1, 2, 3) + +# Parametrelerin anahtar değerlerini almak isterseniz +def anahtar_par(**anahtarlar): + return anahtar + +# Çalıştırdığımızda +anahtar_par(anah1="deg1", anah2="deg2") # => {"anah1": "deg1", "anah2": "deg2"} + + +# İsterseniz, bu ikisini birden kullanabilirsiniz +def tum_argumanlar(*argumanlar, **anahtarla): + print(argumanlar) + print(anahtarla) +""" +tum_argumanlar(1, 2, a=3, b=4) çıktı: + (1, 2) + {"a": 3, "b": 4} +""" + +# Fonksiyonu çağırırken de aynısını kullanabilirsiniz +argumanlar = (1, 2, 3, 4) +anahtarla = {"a": 3, "b": 4} +tum_argumanlar(*argumanlar) # = foo(1, 2, 3, 4) +tum_argumanlar(**anahtarla) # = foo(a=3, b=4) +tum_argumanlar(*argumanlar, **anahtarla) # = foo(1, 2, 3, 4, a=3, b=4) + + +# Fonksiyonlarda kullanacağımız bir değişken oluşturalım +x = 5 + +def belirleX(sayi): + # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil + x = sayi # => 43 + print (x) # => 43 + +def globalBelirleX(sayi): + global x + print (x) # => 5 + x = sayi # global olan x değişkeni artık 6 + print (x) # => 6 + +belirleX(43) +globalBelirleX(6) + + +# Sınıf fonksiyonları oluşturma +def toplama_olustur(x): + def topla(y): + return x + y + return topla + +ekle_10 = toplama_olustur(10) +ekle_10(3) # => 13 + +# Bilinmeyen fonksiyon +(lambda x: x > 2)(3) # => True + +# TODO - Fix for iterables +# Belirli sayıdan yükseğini alma fonksiyonu +map(ekle_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Filtreleme işlemi için liste comprehensions da kullanabiliriz +[ekle_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +#################################################### +## 5. Sınıflar +#################################################### + + +# Sınıf oluşturmak için objeden alt sınıf oluşturacağız. +class Insan(obje): + + # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir + tur = "H. sapiens" + + # Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir. + # Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar + # python tarafından tanımlanan isimlerdir. + # Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız! + def __init__(self, isim): + # Parametreyi sınıfın değerine atayalım + self.isim = isim + + # Bir metot. Bütün metotlar ilk parametre olarak "self "alır. + def soyle(self, mesaj): + return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj) + + # Bir sınıf metotu bütün nesnelere paylaştırılır + # İlk parametre olarak sınıf alırlar + @classmethod + def getir_tur(snf): + return snf.tur + + # Bir statik metot, sınıf ve nesnesiz çağrılır + @staticmethod + def grunt(): + return "*grunt*" + + +# Sınıfı çağıralım +i = Insan(isim="Ahmet") +print(i.soyle("merhaba")) # çıktı "Ahmet: merhaba" + +j = Insan("Ali") +print(j.soyle("selam")) # çıktı "Ali: selam" + +# Sınıf metodumuzu çağıraim +i.getir_tur() # => "H. sapiens" + +# Paylaşılan değeri değiştirelim +Insan.tur = "H. neanderthalensis" +i.getir_tur() # => "H. neanderthalensis" +j.getir_tur() # => "H. neanderthalensis" + +# Statik metodumuzu çağıralım +Insan.grunt() # => "*grunt*" + + +#################################################### +## 6. Moduller +#################################################### + +# Modülleri içe aktarabilirsiniz +import math +print(math.sqrt(16)) # => 4 + +# Modülden belirli bir fonksiyonları alabilirsiniz +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# Modüldeki tüm fonksiyonları içe aktarabilirsiniz +# Dikkat: bunu yapmanızı önermem. +from math import * + +# Modül isimlerini değiştirebilirsiniz. +# Not: Modül ismini kısaltmanız çok daha iyi olacaktır +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Python modulleri aslında birer python dosyalarıdır. +# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün +# ismi ile dosyanın ismi aynı olacaktır. + +# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz. +import math +dir(math) + + +#################################################### +## 7. Gelişmiş +#################################################### + +# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır +def kare_sayilar(nesne): + for i in nesne: + yield i + i + +# Bir oluşturucu(generator) değerleri anında oluşturur. +# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan +# sonra geri döndürür. Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük +# değerler işlenmeyecektir. +# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda +# çok fazla vakit alacaktır. +# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir. +range_ = range(1, 900000000) +# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım +for i in kare_sayilar(range_): + print(i) + if i >= 30: + break + + +# Dekoratörler +# Bu örnekte, +# Eğer lutfen_soyle True ise dönen değer değişecektir. +from functools import wraps + + +def yalvar(hedef_fonksiyon): + @wraps(hedef_fonksiyon) + def metot(*args, **kwargs): + msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs) + if lutfen_soyle: + return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(") + return msj + + return metot + + +@yalvar +def soyle(lutfen_soyle=False): + msj = "Bana soda alır mısın?" + return msj, lutfen_soyle + + +print(soyle()) # Bana soda alır mısın? +print(soyle(lutfen_soyle=True)) # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :( +``` + +## Daha Fazlasına Hazır Mısınız? + +### Ücretsiz Online + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) + +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) +* [Python Course](http://www.python-course.eu/index.php) + +### Kitaplar + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown new file mode 100644 index 00000000..c13f5ecf --- /dev/null +++ b/tr-tr/swift-tr.html.markdown @@ -0,0 +1,588 @@ +--- +language: swift +contributors: + - ["Özgür Şahin", "https://github.com/ozgurshn/"] +filename: learnswift.swift +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. + + +Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı. + +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. + + + +```swift +// modülü import etme +import UIKit + +// +// MARK: Temeller +// + + +//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot + listesinde gruplama yapmanıza olanak sağlıyor +// MARK: Bölüm işareti +// TODO: Daha sonra yapılacak +// FIXME: Bu kodu düzelt + + +//Swift 2 de, println ve print metotları print komutunda birleştirildi. Print + otomatik olarak yeni satır ekliyor. +print("Merhaba dünya") // println print olarak kullanılıyor. +print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar. + +// variables (var) değer atandıktan sonra değiştirilebilir. +// constants (let) değer atndıktan sonra değiştirilemez. + +var degiskenim = 42 +let øπΩ = "deger" // unicode degişken adları +let π = 3.1415926 +let convenience = "keyword" // bağlamsal değişken adı +let isim = "ahmet"; let soyad = "un" // farklı ifadeler noktalı virgül +kullanılarak ayrılabilir. +let `class` = "keyword" // rezerve edilmiş keywordler tek tırnak içerisine +alınarak değişken adı olarak kullanılabilir +let doubleOlduguBelli: Double = 70 +let intDegisken = 0007 // 7 +let largeIntDegisken = 77_000 // 77000 +let etiket = "birseyler " + String(degiskenim) // Cast etme +let piYazi = "Pi = \(π), Pi 2 = \(π * 2)" // String içerisine değiken yazdırma + + +// Builde özel değişkenler +// -D build ayarını kullanır. +#if false + print("yazılmadı") + let buildDegiskeni= 3 +#else + let buildDegiskeni = 7 +#endif +print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7 + +/* + Optionals Swift dilinde bazı değerleri veya yokluğu (None) bir değişkende + tutmanıza olanak sağlar. + + Swift'te her bir degişkeninin bir değeri olması gerektiğinden, nil değeri + bile Optional değer olarak saklanır. + + Optional<T> bir enum'dır. +*/ +var baziOptionalString: String? = "optional" // nil olabilir. +// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay +okunabilir) +var someOptionalString2: Optional<String> = "optional" + + +if baziOptionalString != nil { + // ben nil değilim + if baziOptionalString!.hasPrefix("opt") { + print("ön eki var") + } + + let bos = baziOptionalString?.isEmpty +} +baziOptionalString = nil + +// belirgin olarak acilan(unwrap) opsiyonel (optional) değer +var acilanString: String! = "Değer bekleniliyor" +//yukarıdakiyle aynı ama ! bir postfix operatördür (kolay okunabilir) +var acilanString2: ImplicitlyUnwrappedOptional<String> = "Değer bekleniliyor." + +if let baziOpsiyonelSabitString = baziOptionalString { + // eğer bir değeri varsa, nil değilse + if ! baziOpsiyonelSabitString("tamam") { + // ön eke sahip değil + } +} + +// Swift değişkenlerde herhangi bir tip saklanabilir. +// AnyObject == id +// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle + çalışabilir (Class, Int, struct, etc) +var herhangiBirObject: AnyObject = 7 +herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün" + +/* + Yorumlar buraya + + /* + İç içe yorum yazılması da mümkün + */ +*/ + +// +// MARK: Koleksiyonlar +// + +/* + Array ve Dictionary tipleri aslında structdırlar. Bu yüzden `let` ve `var` + ayrıca bu tipleri tanımlarken değişebilir(var) veya değişemez(let) + olduğunu belirtir. + +*/ + +// Diziler +var liste = ["balik", "su", "limon"] +liste[1] = "şişe su" +let bosDizi = [String]() // let == değiştirilemez +let bosDizi2 = Array<String>() // yukarıdakiyle aynı +var bosDegistirilebilirDizi = [String]() // var == değişebilir + + +// Dictionary +var meslekler = [ + "Kamil": "Kaptan", + "Ayse": "Analist" +] +meslekler["Cansu"] = "Halkla İlişkiler" +let bosDictionary = [String: Float]() // let == değiştirilemez +let bosDictionary2 = Dictionary<String, Float>() // yukarıdakiyle aynı +var bosDegistirilebirDictionary = [String: Float]() // var == değiştirilebilir + + +// +// MARK: Kontroller +// + +// for döngüsü (dizi) +let dizi = [1, 1, 2, 3, 5] +for deger in dizi { + if deger == 1 { + print("Bir!") + } else { + print("Bir degil!") + } +} + +// for döngüsü (dictionary) +var dict = ["one": 1, "two": 2] +for (key, value) in dict { + print("\(key): \(value)") +} + +// for döngüsü (aralık) +for i in -1...liste.count { + print(i) +} +liste[1...2] = ["et", "yogurt"] +// ..< kullanarak son elemanı çıkartabilirsiniz + +// while döngüsü +var i = 1 +while i < 1000 { + i *= 2 +} + +// do-while döngüsü +do { + print("merhaba") +} while 1 == 2 + +// Switch +// Çok güçlü, `if` ifadesenin daha kolay okunabilir hali olarak düşünün +// String, object örnekleri, ve primitif tipleri (Int, Double, vs) destekler. +let sebze = "kırmızı biber" +switch sebze { +case "sogan": + let sebzeYorumu = "Biraz da domates ekle" +case "domates", "salata": + let sebzeYorumu = "İyi bir sandviç olur" +case let lokalScopeDegeri where lokalScopeDegeri.hasSuffix("biber"): + let sebzeYorumu = "Acı bir \(lokalScopeDegeri)?" +default: // zorunludur (tüm olasılıkları yakalamak icin) + let sebzeYorumu = "Corbadaki herseyin tadı güzel" +} + + +// +// MARK: Fonksiyonlar +// + +// Fonksiyonlar first-class tiplerdir, yani başka fonksiyon içine konabilir +// ve parametre olarak geçirilebilirler. + +// Swift dökümanlarıylaa birlikte Fonksiyonlar (format as reStructedText) + +/** + selamlama işlemi + + :param: isim e isim + :param: gun e A gun + :returns: isim ve gunu iceren bir String +*/ +func selam(isim: String, gun: String) -> String { + return "Merhaba \(isim), bugün \(gun)." +} +selam("Can", "Salı") + +// fonksiyon parametre davranışı hariç yukarıdakine benzer +func selam2(#gerekliIsim: String, disParametreIsmi lokalParamtreIsmi: String) -> String { + return "Merhaba \(gerekliIsim), bugün \(lokalParamtreIsmi)" +} +selam2(gerekliIsim:"Can", disParametreIsmi: "Salı") + +// Bir tuple ile birden fazla deger dönen fonksiyon +func fiyatlariGetir() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let fiyatTuple = fiyatlariGetir() +let fiyat = fiyatTuple.2 // 3.79 +// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden +gelir +let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69 +print(fiyat1 == fiyatTuple.1) // true +print("Benzin fiyatı: \(fiyat)") + +// Çeşitli Argümanlar +func ayarla(sayilar: Int...) { + // bu bir dizidir + let sayi = sayilar[0] + let argumanSAyisi = sayilar.count +} + +// fonksiyonu parametre olarak geçirme veya döndürme +func arttirmaIslemi() -> (Int -> Int) { + func birEkle(sayi: Int) -> Int { + return 1 + sayi + } + return birEkle +} +var arttir = arttirmaIslemi() +arttir(7) + +// referans geçirme +func yerDegistir(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +yerDegistir(&someIntA, &someIntB) +print(someIntB) // 7 + + +// +// MARK: Closurelar +// +var sayilar = [1, 2, 6] + +// Fonksiyonlar özelleştirilmiş closurelardır. ({}) + +// Closure örneği. +// `->` parametrelerle dönüş tipini birbirinden ayırır +// `in` closure başlığını closure bodysinden ayırır. +sayilar.map({ + (sayi: Int) -> Int in + let sonuc = 3 * sayi + return sonuc +}) + +// eger tip biliniyorsa, yukarıdaki gibi, şöyle yapabiliriz +sayilar = sayilar.map({ sayi in 3 * sayi }) +// Hatta bunu +//sayilar = sayilar.map({ $0 * 3 }) + +print(sayilar) // [3, 6, 18] + +// Trailing closure +sayilar = sorted(sayilar) { $0 > $1 } + +print(sayilar) // [18, 6, 3] + +// Super kısa hali ise, < operatörü tipleri çıkartabildiği için + +sayilar = sorted(sayilar, < ) + +print(sayilar) // [3, 6, 18] + +// +// MARK: Yapılar +// + +// Structurelar ve sınıflar birçok aynı özelliğe sahiptir. +struct IsimTablosu { + let isimler = [String]() + + // Özelleştirilmiş dizi erişimi + subscript(index: Int) -> String { + return isimler[index] + } +} + +// Structurelar otomatik oluşturulmuş kurucu metoda sahiptir. +let isimTablosu = IsimTablosu(isimler: ["Ben", "Onlar"]) +let isim = isimTablosu[1] +print("İsim \(name)") // İsim Onlar + +// +// MARK: Sınıflar +// + +// Sınıflar, structurelar ve üyeleri 3 seviye erişime sahiptir. +// Bunlar: internal (default), public, private + +public class Sekil { + public func alaniGetir() -> Int { + return 0; + } +} + +// Sınıfın tüm değişkenleri ve metotları publictir. +// Eğer sadece veriyi yapılandırılmış bir objede +// saklamak istiyorsanız, `struct` kullanmalısınız. + +internal class Rect: Sekil { + var yanUzunluk: Int = 1 + + // Özelleştirilmiş getter ve setter propertyleri + private var cevre: Int { + get { + return 4 * yanUzunluk + } + set { + // `newValue ` setterlarda yeni değere erişimi sağlar + yanUzunluk = newValue / 4 + } + } + + // Bir değişkene geç atama(lazy load) yapmak + // altSekil getter cağrılana dek nil (oluşturulmamış) olarak kalır + lazy var altSekil = Rect(yanUzunluk: 4) + + // Eğer özelleştirilmiş getter ve setter a ihtiyacınız yoksa, + // ama bir değişkene get veya set yapıldıktan sonra bir işlem yapmak + // istiyorsanız, `willSet` ve `didSet` metotlarını kullanabilirsiniz + var identifier: String = "defaultID" { + // `willSet` argümanı yeni değer için değişkenin adı olacaktır. + willSet(someIdentifier) { + print(someIdentifier) + } + } + + init(yanUzunluk: Int) { + self. yanUzunluk = yanUzunluk + // super.init i her zaman özelleştirilmiş değerleri oluşturduktan sonra + çağırın + super.init() + } + + func kisalt() { + if yanUzunluk > 0 { + --yanUzunluk + } + } + + override func alaniGetir() -> Int { + return yanUzunluk * yanUzunluk + } +} + +// Basit `Kare` sınıfI `Rect` sınıfını extend ediyor. +class Kare: Rect { + convenience init() { + self.init(yanUzunluk: 5) + } +} + +var benimKarem = Kare() +print(m benimKarem.alaniGetir()) // 25 +benimKarem.kisalt() +print(benimKarem.yanUzunluk) // 4 + +// sınıf örneğini cast etme +let birSekil = benimKarem as Sekil + +// örnekleri karşılaştır, objeleri karşılaştıran == (equal to) ile aynı değil +if benimKarem === benimKarem { + print("Evet, bu benimKarem") +} + +// Opsiyonel init +class Daire: Sekil { + var yaricap: Int + override func alaniGetir() -> Int { + return 3 * yaricap * yaricap + } + + // Eğer init opsiyonelse (nil dönebilir) `init` den sonra soru işareti + // son eki ekle. + init?(yaricap: Int) { + self.yaricap = yaricap + super.init() + + if yaricap <= 0 { + return nil + } + } +} + +var benimDairem = Daire(radius: 1) +print(benimDairem?.alaniGetir()) // Optional(3) +print(benimDairem!. alaniGetir()) // 3 +var benimBosDairem = Daire(yaricap: -1) +print(benimBosDairem?. alaniGetir()) // "nil" +if let daire = benimBosDairem { + // benimBosDairem nil olduğu için çalışmayacak + print("circle is not nil") +} + + +// +// MARK: Enumlar +// + +// Enumlar opsiyonel olarak özel bir tip veya kendi tiplerinde olabilirler. +// Sınıflar gibi metotlar içerebilirler. + +enum Kart { + case Kupa, Maca, Sinek, Karo + func getIcon() -> String { + switch self { + case .Maca: return "♤" + case .Kupa: return "♡" + case .Karo: return "♢" + case .Sinek: return "♧" + } + } +} + +// Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz. +var kartTipi: Kart = .Kupa + +// Integer olmayan enumlar direk değer (rawValue) atama gerektirir. +enum KitapAdi: String { + case John = "John" + case Luke = "Luke" +} +print("Name: \(KitapAdi.John.rawValue)") + +// Değerlerle ilişkilendirilmiş Enum +enum Mobilya { + // Int ile ilişkilendirilmiş + case Masa(yukseklik: Int) + // String ve Int ile ilişkilendirilmiş + case Sandalye(String, Int) + + func aciklama() -> String { + switch self { + case .Masa(let yukseklik): + return "Masa boyu \(yukseklik) cm" + case .Sandalye(let marka, let yukseklik): + return "\(brand) marka sandalyenin boyu \(yukseklik) cm" + } + } +} + +var masa: Mobilya = .Masa(yukseklik: 80) +print(masa.aciklama()) // "Masa boyu 80 cm" +var sandalye = Mobilya.Sandalye("Foo", 40) +print(sandalye.aciklama()) // "Foo marka sandalyenin boyu 40 cm" + + +// +// MARK: Protokoller +// + +// `protocol` onu kullanan tiplerin bazı özel değişkenleri, metotları, +// tip metotlarını,opertörleri ve alt indisleri (subscripts) içermesini +// zorunlu hale getirebilir. + +protocol SekilUretici { + var aktif: Bool { get set } + func sekilOlustur() -> Sekil +} + +// @objc ile tanımlanan protokoller, uygunluğu kontrol edebilmenizi sağlayacak +// şekilde opsiyonel fonksiyonlara izin verir +@objc protocol SekliDondur { + optional func sekillendirilmis() + optional func sekillendirilebilir() -> Bool +} + +class BenimSeklim: Rect { + var delegate: SekliDondur? + + func buyut() { + yanUzlunluk += 2 + + // Bir çalışma zamanı hatası("optional chaining") fırlatmak yerine nil + //değeri görmezden gelerek nil dönmek için opsiyonel değişken, metot veya + // altindisten sonra soru işareti koyabilirsiniz. + if let izinVeriyormu = self.delegate?.sekillendirilebilir?() { + // önce delegate i sonra metodu test edin + self.delegate?.sekillendirilmis?() + } + } +} + + +// +// MARK: Diğerleri +// + +// `extension`lar: Var olan tiplere ekstra özellikler ekleyin + +// Kare artık `Printable` protokolüne uyuyor. +extension Kare: Printable { + var description: String { + return "Alan: \(alaniGetir()) - ID: \(self.identifier)" + } +} + +print("Kare: \(benimKarem)") + +// Dahili tipleri de yeni özellikler ekleyebilirsiniz +extension Int { + var customProperty: String { + return "Bu sayı \(self)" + } + + func carp(num: Int) -> Int { + return num * self + } +} + +print(7.customProperty) // "Bu sayı 7" +print(14.carp(3)) // 42 + +// Genericler: Java ve C#'a benzer şekilde. `where` anahtar kelimesini +// kullanarak genericlerin özelliklerini belirleyin + +func indexiBul<T: Equatable>(dizi: [T], bulunacakDeger: T) -> Int? { + for (index, deger) in enumerate(dizi) { + if deger == bulunacakDeger { + return index + } + } + return nil +} +let bulunanIndex = indexiBul([1, 2, 3, 4], 3) +print(bulunanIndex == 2) // true + +// Operatorler: +// Özel operatorler şu karakterlerle başlayabilir: +// / = - + * % < > ! & | ^ . ~ +// veya +// Unicode math, symbol, arrow, dingbat, ve line/box karakterleri. +prefix operator !!! {} + +// Yan uzunluğu 3 katına çıkartan prefix operatörü +prefix func !!! (inout sekil: Kare) -> Kare { + sekil.YanUzunluk *= 3 + return sekil +} + +// güncel deger +print(benimKarem.YanUzunluk) // 4 + +// yan uzunluğu !!! operatorü kullanarak 3 katına çıkar +!!!benimKarem +print(benimKarem.YanUzunluk) // 12 +``` diff --git a/typescript.html.markdown b/typescript.html.markdown new file mode 100644 index 00000000..e9135510 --- /dev/null +++ b/typescript.html.markdown @@ -0,0 +1,169 @@ +--- +language: TypeScript +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +filename: learntypescript.ts +--- + +TypeScript is a language that aims at easing development of large scale applications written in JavaScript. +TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript. +It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript. + +This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/). + +To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript. + +```js +// There are 3 basic types in TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// When it's impossible to know, there is the "Any" type +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // okay, definitely a boolean + +// For collections, there are typed arrays and generic arrays +var list: number[] = [1, 2, 3]; +// Alternatively, using the generic array type +var list: Array<number> = [1, 2, 3]; + +// For enumerations: +enum Color {Red, Green, Blue}; +var c: Color = Color.Green; + +// Lastly, "void" is used in the special case of a function returning nothing +function bigHorribleAlert(): void { + alert("I'm a little annoying box!"); +} + +// Functions are first class citizens, support the lambda "fat arrow" syntax and +// use type inference + +// The following are equivalent, the same signature will be infered by the +// compiler, and same JavaScript will be emitted +var f1 = function(i: number): number { return i * i; } +// Return type inferred +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Return type inferred +var f4 = (i: number) => { return i * i; } +// Return type inferred, one-liner means no return keyword needed +var f5 = (i: number) => i * i; + +// Interfaces are structural, anything that has the properties is compliant with +// the interface +interface Person { + name: string; + // Optional properties, marked with a "?" + age?: number; + // And of course functions + move(): void; +} + +// Object that implements the "Person" interface +// Can be treated as a Person since it has the name and move properties +var p: Person = { name: "Bobby", move: () => {} }; +// Objects that have the optional property: +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// Is not a person because age is not a number +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Interfaces can also describe a function type +interface SearchFunc { + (source: string, subString: string): boolean; +} +// Only the parameters' types are important, names are not important. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Classes - members are public by default +class Point { + // Properties + x: number; + + // Constructor - the public/private keywords in this context will generate + // the boiler plate code for the property and the initialization in the + // constructor. + // In this example, "y" will be defined just like "x" is, but with less code + // Default values are also supported + + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Functions + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Static members + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); //y will be 0 + +// Inheritance +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + super(x, y); // Explicit call to the super class constructor is mandatory + } + + // Overwrite + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Modules, "." can be used as separator for sub modules +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Local alias for referencing a module +import G = Geometry; + +var s2 = new G.Square(10); + +// Generics +// Classes +class Tuple<T1, T2> { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair<T> { + item1: T; + item2: T; +} + +// And functions +var pairToTuple = function<T>(p: Pair<T>) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Including references to a definition file: +/// <reference path="jquery.d.ts" /> + +``` + +## Further Reading + * [TypeScript Official website] (http://www.typescriptlang.org/) + * [TypeScript language specifications (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript) + * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) diff --git a/vi-vn/git-vi.html.markdown b/vi-vn/git-vi.html.markdown new file mode 100644 index 00000000..1bcc94a0 --- /dev/null +++ b/vi-vn/git-vi.html.markdown @@ -0,0 +1,403 @@ +---
+category: tool
+tool: git
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"] + - ["Vinh Nguyen", "https://twitter.com/vinhnx"]
+filename: LearnGit-vi.txt
+lang: vi-vn
+---
+
+Git là một hệ quản lý mã nguồn và phiên bản phân tán (distributed version control and source code management system).
+
+Nó làm được điều này là do một loạt các snapshot từ đề án của bạn, và nó hoạt động
+với các snapshot đó để cung cấp cho bạn với chức năng đến phiên bản và
+quản lý mã nguồn của bạn.
+
+## Khái Niệm Versioning
+
+### Version Control là gì?
+
+Version Control là một hệ thống ghi lại những thay đổi ở một tập tin, hay một nhóm các tập tin, theo thời gian.
+
+### So sánh giữa Centralized Versioning và Distributed Versioning
+
+* Quản lý phiên bản tập trung (Centralized Versioning) tập trung vào việc đồng bộ hóa, theo dõi, và lưu trữ tập tin.
+* Quản lý phiên bản phân tán (Distributed Versioning) tập trung vào việc chia sẻ các thay đổi. Mỗi sự thay đổi có một mã định dạng (id) duy nhất.
+* Các hệ phân tán không có cấu trúc định sẵn. Bạn có thể thay đổi một kiểu SVN, hệ phân tán, với git.
+
+[Thông tin thêm](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Tại Sao Dùng Git?
+
+* Có thể hoạt động offline.
+* Cộng tác với nhau rất dễ dàng!
+* Phân nhánh dễ dàng!
+* Trộn (Merging)
+* Git nhanh.
+* Git linh hoạt.
+
+## Kiến Trúc Git
+
+
+### Repository
+
+Một nhóm các tập tin, thư mục, các ghi chép trong quá khứ, commit, và heads. Tưởng tượng nó như là một cấu trúc dữ liệu mã nguồn,
+với thuộc tính mà một "nhân tố" mã nguồn cho bạn quyền truy cập đến lịch sử sửa đổi, và một số thứ khác.
+
+Một git repository bao gồm thư mục .git & tree đang làm việc.
+
+### Thư mục .git (thành phần của một repository)
+
+Thư mục .git chứa tất cả các cấu hình, log, nhánh, HEAD, và hơn nữa.
+[Danh Sách Chi Tiết.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Tree Đang Làm (thành phần của một repository)
+
+Đây cơ bản là các thư mục và tập tin trong repository của bạn. Nó thường được tham chiếu
+thư mục đang làm việc của bạn
+
+### Chỉ mục (thành phần của một thư mục .git)
+
+Chỉ mục của là một staging area trong git. Nó đơn giản là một lớp riêng biệt với tree đang làm việc của bạn
+từ Git repository. Điều này cho nhà phát triền nhiều lựa chọn hơn trong việc xem xét những gì được gửi đến Git
+repository.
+
+### Commit
+
+Một git commit là một snapshot của một nhóm các thay đổi, hoặc các thao tác Working Tree của bạn.
+Ví dụ, nếu bạn thêm 5 tập tin, và xóa 2 tập tin khác, những thay đổi này sẽ được chứa trong
+một commit (hoặc snapshot). Commit này có thể được đẩy đến các repo khác, hoặc không!
+
+### Nhánh
+
+Nhánh thực chất là một con trỏ đến commit mới nhất mà bạn vừa thực hiện. Khi bạn commit,
+con trỏ này sẽ cập nhật tự động và trỏ đến commit mới nhất.
+
+### HEAD và head (thành phần của thư mục .git)
+
+HEAD là một con trỏ đến branch hiện tại. Một repo chỉ có một HEAD *đang hoạt động*.
+head là một con trỏ đến bất kỳ commit nào. Một repo có thể có nhiều head.
+
+### Các Tài Nguyên Mang Tính Khái Niệm
+
+* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Các Lệnh
+
+
+### init
+
+Tạo một repo Git rỗng. Các cài đặt, thông tin lưu trữ... của Git
+được lưu ở một thư mục tên là ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Để chỉnh tùy chọn. Bất kể là cho repo, hay cho hệ thống, hay điều chỉnh
+toàn cục (global)
+
+
+
+```bash
+# In Ra & Và Gán Một Số Biến Tùy Chỉnh Cơ Bản (Toàn cục - Global)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[Tìm hiểu thêm về git config.](http://git-scm.com/docs/git-config)
+
+### help
+
+Để cho bạn lối truy cập nhanh đến một chỉ dẫn cực kỳ chi tiết của từng lệnh. Hoặc chỉ để
+nhắc bạn một số cú pháp.
+
+```bash
+# Xem nhanh các lệnh có sẵn
+$ git help
+
+# Xem tất các các lệnh
+$ git help -a
+
+# Lệnh help riêng biệt - tài liệu người dùng
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Để hiển thị sự khác nhau giữa tập tin index (cơ bản là repo đang làm việc) và HEAD commit
+hiện tại.
+
+
+```bash
+# Sẽ hiển thị nhánh, các tập tin chưa track (chưa commit), các thay đổi và những khác biệt khác
+$ git status
+
+# Để xem các "tid bits" về git status
+$ git help status
+```
+
+### add
+
+Để thêm các tập vào tree/thư mục/repo hiện tại. Nếu bạn không `git add` các tập tin mới đến
+tree/thư mục hiện tại, chúng sẽ không được kèm theo trong các commit!
+
+```bash
+# thêm một file vào thư mục hiện tại
+$ git add HelloWorld.java
+
+# thêm một file vào một thư mục khác
+$ git add /path/to/file/HelloWorld.c
+
+# Hỗ trợ Regular Expression!
+$ git add ./*.java
+```
+
+### branch
+
+Quản lý nhánh (branch). Bạn có thể xem, sửa, tạo, xóa các nhánh bằng cách dùng lệnh này.
+
+```bash
+# liệt kê các branch đang có và ở remote
+$ git branch -a
+
+# tạo branch mới
+$ git branch myNewBranch
+
+# xóa một branch
+$ git branch -d myBranch
+
+# đặt tên lại một branch
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# chỉnh sửa diễn giải của một branch
+$ git branch myBranchName --edit-description
+```
+
+### checkout
+
+Cập nhật tất cả các file trong tree hiện tại để cho trùng khớp với phiên bản của index, hoặc tree cụ thể.
+
+```bash
+# Checkout (chuyển) một repo - mặc định là nhánh master
+$ git checkout
+# Checkout một nhánh cụ thể
+$ git checkout branchName
+# Tạo một nhánh mới và chuyển đến nó, tương tự: "git branch <name>; git checkout <name>"
+$ git checkout -b newBranch
+```
+
+### clone
+
+Nhân bản, hoặc sao chép, một repo hiện có thành một thư mục mới. Nó cũng thêm
+các branch có remote-tracking cho mỗi branch trong một repo được nhân bản, mà
+cho phép bạn push đến một remote branch.
+
+```bash
+# Nhân bản learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+```
+
+### commit
+
+Lưu trữ nội dung hiện tại của index trong một "commit" mới. Điều này cho phép tạo ra thay đổi và một ghi chú tạo ra bởi người dùng.
+
+```bash
+# commit với một ghi chú
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+```
+
+### diff
+
+Hiển thị sự khác biệt giữa một file trong thư mục hiện tại, index và commits.
+
+```bash
+# Hiển thị sự khác biệt giữa thư mục hiện tại và index
+$ git diff
+
+# Hiển thị khác biệt giữa index và commit mới nhất.
+$ git diff --cached
+
+# Hiển thị khác biệt giữa thư mục đang làm việc và commit mới nhất
+$ git diff HEAD
+```
+
+### grep
+
+Cho phép bạn tìm kiếm nhanh một repo.
+
+Các tinh chỉnh tùy chọn:
+
+```bash
+# Cảm ơn Travis Jeffery vì những lệnh này
+# Đặt số của dòng được hiển thị trong kết quả tìm kiếm grep
+$ git config --global grep.lineNumber true
+
+# Làm cho kết quả tìm kiếm dễ đọc hơn, bao gồm cả gom nhóm
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Tìm "variableName" trong tất cả các file Java
+$ git grep 'variableName' -- '*.java'
+
+# Tìm một dòng mà có chứa "arrayListName" và, "add" hoặc "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Google để xem thêm các ví dụ
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Hiển thị các commit đến repo.
+
+```bash
+# Hiện tất cả các commit
+$ git log
+
+# Hiện X commit
+$ git log -n 10
+
+# Chỉ hiện các commit đã merge merge commits
+$ git log --merges
+```
+
+### merge
+
+"Trộn" các thay đổi từ commit bên ngoài vào trong nhánh hiện tại.
+
+```bash
+# Merge branch cụ thể vào branch hiện tại.
+$ git merge branchName
+
+# Luôn khởi tạo một merge commit khi trộn (merge)
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Đặt lại tên hoặc di chuyển một file
+
+```bash
+# Đặt lại tên một file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Di chuyển một file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Buộc đặt lại tên hoặc di chuyển
+# "existingFile" đã tồn tại trong thự mục, sẽ bị ghi đè
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Pull về từ một repo và merge nó vào branch khác.
+
+```bash
+# Cập nhật repo local của bạn, bằng cách merge các thay đổi mới
+# từ remote "origin" và nhánh "master".
+# git pull <remote> <branch>
+# git pull => hoàn toàn mặc định như => git pull origin master
+$ git pull origin master
+
+# Merge các thay đổi từ remote branch và rebase
+# các commit trong branch lên trên local repo, như sau: "git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+push và merge các thay đổi từ một branch đến một remote & branch.
+
+```bash +# Push và merge các thay đổi từ một repo local đến một +# remote có tên là "origin" và nhánh "master". +# git push <remote> <branch> +# git push => mặc định ẩn đến => git push origin master +$ git push origin master + +# Để liên kết đến một branch local với một branch remote, thêm vào cờ -u: +$ git push -u origin master +# Từ lúc này, bất cứ khi nào bạn muốn push từ cùng một nhánh local đó, sử dụng lối tắt: +$ git push +```
+
+### rebase (thận trọng)
+
+Lấy tất cả các thay đổi mà đã được commit trên một nhánh, và replay (?) chúng trên một nhánh khác.
+*Không rebase các commit mà bạn đã push đến một repo công khai*.
+
+```bash
+# Rebase experimentBranch lên master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Đọc Thêm.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (thận trọng)
+
+Thiết lập lạo HEAD hiện tại đến một trạng thái cụ thể. Điều này cho phép bạn làm lại các merges,
+pulls, commits, thêm, and hơn nữa. Nó là một lệnh hay nhưng cũng nguy hiểm nếu bạn không
+biết mình đang làm gì.
+
+```bash
+# Thiết lập lại staging area, để trùng với commit mới nhất (để thư mục không thay đổi)
+$ git reset
+
+# Thiết lập lại staging area, để trùng với commit mới nhất, và ghi đè lên thư mục hiện tại
+$ git reset --hard
+
+# Di chuyển nhánh hiện tại đến một commit cụ thể (để thư mục không thay đổi)
+# tất cả thay đổi vẫn duy trì trong thư mục.
+$ git reset 31f2bb1
+
+# Di chuyển nhánh hiện tại lùi về một commit cụ thể
+# và làm cho thư mục hiện tại trùng (xóa các thay đổi chưa được commit và tất cả các commit
+# sau một commit cụ thể).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Ngược lại với git add, git rm xóa file từ tree đang làm việc.
+
+```bash
+# xóa HelloWorld.c
+$ git rm HelloWorld.c
+
+# Xóa file từ thư mục khác
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Thông tin thêm
+
+* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video Tutorials](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/) + +* [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html) +
+ diff --git a/vi-vn/objective-c-vi.html.markdown b/vi-vn/objective-c-vi.html.markdown new file mode 100644 index 00000000..c97bb560 --- /dev/null +++ b/vi-vn/objective-c-vi.html.markdown @@ -0,0 +1,318 @@ +---
+
+language: Objective-C
+contributors:
+ - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+ - ["Yannick Loriot", "https://github.com/YannickL"]
+lang: vi-vn
+filename: LearnObjectiveC-vi.m
+
+---
+
+Objective-C là ngôn ngữ lập trình chính được sử dụng bởi Apple cho các hệ điều hành OS X, iOS và các framework tương ứng của họ, Cocoa và Cocoa Touch.
+Nó là một ngôn ngữ lập trình mục đích tổng quát, hướng đối tượng có bổ sung thêm kiểu truyền thông điệp giống Smalltalk vào ngôn ngữ lập trình C.
+
+```objective_c
+// Chú thích dòng đơn bắt đầu với //
+
+/*
+Chú thích đa dòng trông như thế này.
+*/
+
+// Nhập các headers của framework Foundation với cú pháp #import
+#import <Foundation/Foundation.h>
+#import "MyClass.h"
+
+// Đầu vào chương trình của bạn là một hàm gọi là
+// main với một kiểu trả về kiểu integer.
+int main (int argc, const char * argv[])
+{
+ // Tạo một autorelease pool để quản lý bộ nhớ vào chương trình
+ NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+
+ // Sử dụng hàm NSLog() để in ra các dòng lệnh vào console
+ NSLog(@"Hello World!"); // Print the string "Hello World!"
+
+ ///////////////////////////////////////
+ // Kiểu & Biến (Types & Variables)
+ ///////////////////////////////////////
+
+ // Khai báo số nguyên
+ int myPrimitive1 = 1;
+ long myPrimitive2 = 234554664565;
+
+ // Khai báo đối tượng
+ // Đặt dấu nháy * vào trước tên biến cho khai báo đối tượng strong
+ MyClass *myObject1 = nil; // Strong
+ id myObject2 = nil; // Weak
+ // %@ là một đối tượng
+ // 'miêu tả' ('desciption') là thông lệ để trình bày giá trị của các Đối tượng
+ NSLog(@"%@ và %@", myObject1, [myObject2 description]); // In ra "(null) và (null)"
+
+ // Chuỗi
+ NSString *worldString = @"World";
+ NSLog(@"Hello %@!", worldString); // In ra "Hello World!"
+
+ // Ký tự literals
+ NSNumber *theLetterZNumber = @'Z';
+ char theLetterZ = [theLetterZNumber charValue];
+ NSLog(@"%c", theLetterZ);
+
+ // Số nguyên literals
+ NSNumber *fortyTwoNumber = @42;
+ int fortyTwo = [fortyTwoNumber intValue];
+ NSLog(@"%i", fortyTwo);
+
+ NSNumber *fortyTwoUnsignedNumber = @42U;
+ unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue];
+ NSLog(@"%u", fortyTwoUnsigned);
+
+ NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
+ short fortyTwoShort = [fortyTwoShortNumber shortValue];
+ NSLog(@"%hi", fortyTwoShort);
+
+ NSNumber *fortyTwoLongNumber = @42L;
+ long fortyTwoLong = [fortyTwoLongNumber longValue];
+ NSLog(@"%li", fortyTwoLong);
+
+ // Dấu phẩy động (floating point) literals
+ NSNumber *piFloatNumber = @3.141592654F;
+ float piFloat = [piFloatNumber floatValue];
+ NSLog(@"%f", piFloat);
+
+ NSNumber *piDoubleNumber = @3.1415926535;
+ double piDouble = [piDoubleNumber doubleValue];
+ NSLog(@"%f", piDouble);
+
+ // BOOL literals
+ NSNumber *yesNumber = @YES;
+ NSNumber *noNumber = @NO;
+
+ // Đối tượng Mảng
+ NSArray *anArray = @[@1, @2, @3, @4];
+ NSNumber *thirdNumber = anArray[2];
+ NSLog(@"Third number = %@", thirdNumber); // In ra "Third number = 3"
+
+ // Đối tượng Từ điển
+ NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
+ NSObject *valueObject = aDictionary[@"A Key"];
+ NSLog(@"Đối tượng = %@", valueObject); // In ra "Object = (null)"
+
+ ///////////////////////////////////////
+ // Toán Tử (Operators)
+ ///////////////////////////////////////
+
+ // Các toán tử cũng hoạt động giống như ngôn ngữ C
+ // Ví dụ:
+ 2 + 5; // => 7
+ 4.2f + 5.1f; // => 9.3f
+ 3 == 2; // => 0 (NO)
+ 3 != 2; // => 1 (YES)
+ 1 && 1; // => 1 (Logical and)
+ 0 || 1; // => 1 (Logical or)
+ ~0x0F; // => 0xF0 (bitwise negation)
+ 0x0F & 0xF0; // => 0x00 (bitwise AND)
+ 0x01 << 1; // => 0x02 (bitwise dịch trái (bởi 1))
+
+ /////////////////////////////////////////////
+ // Cấu Trúc Điều Khiển (Controls Structures)
+ /////////////////////////////////////////////
+
+ // Câu lệnh If-Else
+ if (NO)
+ {
+ NSLog(@"I am never run");
+ } else if (0)
+ {
+ NSLog(@"I am also never run");
+ } else
+ {
+ NSLog(@"I print");
+ }
+
+ // Câu lệnh Switch
+ switch (2)
+ {
+ case 0:
+ {
+ NSLog(@"I am never run");
+ } break;
+ case 1:
+ {
+ NSLog(@"I am also never run");
+ } break;
+ default:
+ {
+ NSLog(@"I print");
+ } break;
+ }
+
+ // Câu lệnh vòng lặp While
+ int ii = 0;
+ while (ii < 4)
+ {
+ NSLog(@"%d,", ii++); // ii++ tăng dần, sau khi sử dụng giá trị của nó.
+ } // => in ra "0,"
+ // "1,"
+ // "2,"
+ // "3,"
+
+ // Câu lệnh vòng lặp For
+ int jj;
+ for (jj=0; jj < 4; jj++)
+ {
+ NSLog(@"%d,", jj);
+ } // => in ra "0,"
+ // "1,"
+ // "2,"
+ // "3,"
+
+ // Câu lệnh Foreach
+ NSArray *values = @[@0, @1, @2, @3];
+ for (NSNumber *value in values)
+ {
+ NSLog(@"%@,", value);
+ } // => in ra "0,"
+ // "1,"
+ // "2,"
+ // "3,"
+
+ // Câu lệnh Try-Catch-Finally
+ @try
+ {
+ // Your statements here
+ @throw [NSException exceptionWithName:@"FileNotFoundException"
+ reason:@"Không Tìm Thấy Tập Tin trên Hệ Thống" userInfo:nil];
+ } @catch (NSException * e)
+ {
+ NSLog(@"Exception: %@", e);
+ } @finally
+ {
+ NSLog(@"Finally");
+ } // => in ra "Exception: Không Tìm Thấy Tập Tin trên Hệ Thống"
+ // "Finally"
+
+ ///////////////////////////////////////
+ // Đối Tượng (Objects)
+ ///////////////////////////////////////
+
+ // Tạo một thực thể đối tượng bằng cách phân vùng nhớ và khởi tạo đối tượng đó.
+ // Một đối tượng sẽ không thật sự hoạt động cho đến khi cả 2 bước alloc] init] được hoàn thành
+ MyClass *myObject = [[MyClass alloc] init];
+
+ // Mô hình lập trình hướng đối tượng của Objective-C dựa trên việc truyền thông điệp (message)
+ // và các thực thể đối tượng với nhau.
+ // Trong Objective-C một đối tượng không đơn thuần gọi phương thức; nó truyền thông điệp.
+ [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+ // Dọn dẹp vùng nhớ mà bạn đã dùng ở chương trình
+ [pool drain];
+
+ // Kết thúc chương trình
+ return 0;
+}
+
+///////////////////////////////////////
+// Lớp và Hàm (Classes & Functions)
+///////////////////////////////////////
+
+// Khai báo lớp của bạn ở một tập tin header (MyClass.h):
+// Cú pháp Khai Báo Lớp:
+// @interface ClassName : ParentClassName <ImplementedProtocols>
+// {
+// Khai báo biến thành viên;
+// }
+// -/+ (type) Khai báo method;
+// @end
+@interface MyClass : NSObject <MyProtocol>
+{
+ int count;
+ id data;
+ NSString *name;
+}
+// Ký hiệu (notation) tiện ích để tự động khởi tạo public getter và setter
+@property int count;
+@property (copy) NSString *name; // Sao chép đối tượng trong quá trình gán.
+@property (readonly) id data; // Chỉ khai báo phương thức getter.
+
+// Phương thức
++/- (return type)methodSignature:(Parameter Type *)parameterName;
+
+// dấu '+' cho phương thức lớp
++ (NSString *)classMethod;
+
+// dấu '-' cho phương thức thực thể
+- (NSString *)instanceMethodWithParameter:(NSString *)string;
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
+
+@end
+
+// Thực thi các phương thức trong một tập tin thực thi (MyClass.m):
+
+@implementation MyClass
+
+// Gọi khi đối tượng được release
+- (void)dealloc
+{
+}
+
+// Phương thức khởi tạo (Constructors) là một cách để tạo các lớp
+// Đây là phương thức khởi tạo mặc định được gọi khi đối tượng được khởi tạo
+- (id)init
+{
+ if ((self = [super init]))
+ {
+ self.count = 1;
+ }
+ return self;
+}
+
++ (NSString *)classMethod
+{
+ return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParameter:(NSString *)string
+{
+ return @"New string";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+ return @42;
+}
+
+// Các phương thức được khai báo vào MyProtocol
+- (void)myProtocolMethod
+{
+ // câu lệnh
+}
+
+@end
+
+/*
+ * Một protocol khai báo các phương thức mà có thể thực thi bởi bất kỳ lớp nào.
+ * Các protocol chính chúng không phải là các lớp. Chúng chỉ đơn giản là định ra giao diện (interface)
+ * mà các đối tượng khác có trách nhiệm sẽ thực thi.
+ */
+@protocol MyProtocol
+ - (void)myProtocolMethod;
+@end
+
+
+
+```
+## Xem Thêm
+
++ [Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)
+
++ Apple Docs':
+ + [Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)
+
+ + [Programming With Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html)
+
+ + [Object-Oriented Programming with Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40005149)
+
+ + [Coding Guidelines for Cocoa](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html)
+
++ [iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown new file mode 100644 index 00000000..bdfdcc10 --- /dev/null +++ b/visualbasic.html.markdown @@ -0,0 +1,281 @@ +--- +language: Visual Basic +contributors: + - ["Brian Martin", "http://brianmartin.biz"] +filename: learnvisualbasic.vb +--- + +```vb +Module Module1 + + Sub Main() + ' A Quick Overview of Visual Basic Console Applications before we dive + ' in to the deep end. + ' Apostrophe starts comments. + ' To Navigate this tutorial within the Visual Basic Complier, I've put + ' together a navigation system. + ' This navigation system is explained however as we go deeper into this + ' tutorial, you'll understand what it all means. + Console.Title = ("Learn X in Y Minutes") + Console.WriteLine("NAVIGATION") 'Display + Console.WriteLine("") + Console.ForegroundColor = ConsoleColor.Green + Console.WriteLine("1. Hello World Output") + Console.WriteLine("2. Hello World Input") + Console.WriteLine("3. Calculating Whole Numbers") + Console.WriteLine("4. Calculating Decimal Numbers") + Console.WriteLine("5. Working Calculator") + Console.WriteLine("6. Using Do While Loops") + Console.WriteLine("7. Using For While Loops") + Console.WriteLine("8. Conditional Statements") + Console.WriteLine("9. Select A Drink") + Console.WriteLine("50. About") + Console.WriteLine("Please Choose A Number From The Above List") + Dim selection As String = Console.ReadLine + Select Case selection + Case "1" 'HelloWorld Output + Console.Clear() 'Clears the application and opens the private sub + HelloWorldOutput() 'Name Private Sub, Opens Private Sub + Case "2" 'Hello Input + Console.Clear() + HelloWorldInput() + Case "3" 'Calculating Whole Numbers + Console.Clear() + CalculatingWholeNumbers() + Case "4" 'Calculting Decimal Numbers + Console.Clear() + CalculatingDecimalNumbers() + Case "5" 'Working Calcculator + Console.Clear() + WorkingCalculator() + Case "6" 'Using Do While Loops + Console.Clear() + UsingDoWhileLoops() + Case "7" 'Using For While Loops + Console.Clear() + UsingForLoops() + Case "8" 'Conditional Statements + Console.Clear() + ConditionalStatement() + Case "9" 'If/Else Statement + Console.Clear() + IfElseStatement() 'Select a drink + Case "50" 'About msg box + Console.Clear() + Console.Title = ("Learn X in Y Minutes :: About") + MsgBox("This tutorial is by Brian Martin (@BrianMartinn") + Console.Clear() + Main() + Console.ReadLine() + + End Select + End Sub + + 'One - I'm using numbers to help with the above navigation when I come back + 'later to build it. + + 'We use private subs to seperate different sections of the program. + Private Sub HelloWorldOutput() + 'Title of Console Application + Console.Title = "Hello World Ouput | Learn X in Y Minutes" + 'Use Console.Write("") or Console.WriteLine("") to print outputs. + 'Followed by Console.Read() alternatively Console.Readline() + 'Console.ReadLine() prints the output to the console. + Console.WriteLine("Hello World") + Console.ReadLine() + End Sub + + 'Two + Private Sub HelloWorldInput() + Console.Title = "Hello World YourName | Learn X in Y Minutes" + ' Variables + ' Data entered by a user needs to be stored. + ' Variables also start with a Dim and end with an As VariableType. + + ' In this tutorial, we want to know what your name, and make the program + ' respond to what is said. + Dim username As String + 'We use string as string is a text based variable. + Console.WriteLine("Hello, What is your name? ") 'Ask the user their name. + username = Console.ReadLine() 'Stores the users name. + Console.WriteLine("Hello " + username) 'Output is Hello 'Their name' + Console.ReadLine() 'Outsputs the above. + 'The above will ask you a question followed by printing your answer. + 'Other variables include Integer and we use Integer for whole numbers. + End Sub + + 'Three + Private Sub CalculatingWholeNumbers() + Console.Title = "Calculating Whole Numbers | Learn X in Y Minutes" + Console.Write("First number: ") 'Enter a whole number, 1, 2, 50, 104 ect + Dim a As Integer = Console.ReadLine() + Console.Write("Second number: ") 'Enter second whole number. + Dim b As Integer = Console.ReadLine() + Dim c As Integer = a + b + Console.WriteLine(c) + Console.ReadLine() + 'The above is a simple calculator + End Sub + + 'Four + Private Sub CalculatingDecimalNumbers() + Console.Title = "Calculating with Double | Learn X in Y Minutes" + 'Of course we would like to be able to add up decimals. + 'Therefore we could change the above from Integer to Double. + + 'Enter a whole number, 1.2, 2.4, 50.1, 104.9 ect + Console.Write("First number: ") + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") 'Enter second whole number. + Dim b As Double = Console.ReadLine + Dim c As Double = a + b + Console.WriteLine(c) + Console.ReadLine() + 'Therefore the above program can add up 1.1 - 2.2 + End Sub + + 'Five + Private Sub WorkingCalculator() + Console.Title = "The Working Calculator| Learn X in Y Minutes" + 'However if you'd like the calculator to subtract, divide, multiple and + 'add up. + 'Copy and paste the above again. + Console.Write("First number: ") + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") 'Enter second whole number. + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + 'By adding the below lines we are able to calculate the subtract, + 'multply as well as divide the a and b values + Console.Write(a.ToString() + " + " + b.ToString()) + 'We want to pad the answers to the left by 3 spaces. + Console.WriteLine(" = " + c.ToString.PadLeft(3)) + Console.Write(a.ToString() + " * " + b.ToString()) + Console.WriteLine(" = " + d.ToString.PadLeft(3)) + Console.Write(a.ToString() + " - " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.Write(a.ToString() + " / " + b.ToString()) + Console.WriteLine(" = " + f.ToString.PadLeft(3)) + Console.ReadLine() + + End Sub + + 'Six + Private Sub UsingDoWhileLoops() + 'Just as the previous private sub + 'This Time We Ask If The User Wishes To Continue (Yes or No?) + 'We're using Do While Loop as we're unsure if the user wants to use the + 'program more than once. + Console.Title = "UsingDoWhileLoops | Learn X in Y Minutes" + Dim answer As String 'We use the variable "String" as the answer is text + Do 'We start the program with + Console.Write("First number: ") + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + Console.Write(a.ToString() + " + " + b.ToString()) + Console.WriteLine(" = " + c.ToString.PadLeft(3)) + Console.Write(a.ToString() + " * " + b.ToString()) + Console.WriteLine(" = " + d.ToString.PadLeft(3)) + Console.Write(a.ToString() + " - " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.Write(a.ToString() + " / " + b.ToString()) + Console.WriteLine(" = " + f.ToString.PadLeft(3)) + Console.ReadLine() + 'Ask the question, does the user wish to continue? Unfortunately it + 'is case sensitive. + Console.Write("Would you like to continue? (yes / no)") + 'The program grabs the variable and prints and starts again. + answer = Console.ReadLine + 'The command for the variable to work would be in this case "yes" + Loop While answer = "yes" + + End Sub + + 'Seven + Private Sub UsingForLoops() + 'Sometimes the program only needs to run once. + 'In this program we'll be counting down from 10. + + Console.Title = "Using For Loops | Learn X in Y Minutes" + 'Declare Variable and what number it should count down in Step -1, + 'Step -2, Step -3 ect. + For i As Integer = 10 To 0 Step -1 + Console.WriteLine(i.ToString) 'Print the value of the counter + Next i 'Calculate new value + Console.WriteLine("Start") 'Lets start the program baby!! + Console.ReadLine() 'POW!! - Perhaps I got a little excited then :) + End Sub + + 'Eight + Private Sub ConditionalStatement() + Console.Title = "Conditional Statements | Learn X in Y Minutes" + Dim userName As String = Console.ReadLine + Console.WriteLine("Hello, What is your name? ") 'Ask the user their name. + userName = Console.ReadLine() 'Stores the users name. + If userName = "Adam" Then + Console.WriteLine("Hello Adam") + Console.WriteLine("Thanks for creating this useful site") + Console.ReadLine() + Else + Console.WriteLine("Hello " + userName) + Console.WriteLine("Have you checked out www.learnxinyminutes.com") + Console.ReadLine() 'Ends and prints the above statement. + End If + End Sub + + 'Nine + Private Sub IfElseStatement() + Console.Title = "If / Else Statement | Learn X in Y Minutes" + 'Sometimes it is important to consider more than two alternatives. + 'Sometimes there are a good few others. + 'When this is the case, more than one if statement would be required. + 'An if statement is great for vending machines. Where the user enters a code. + 'A1, A2, A3, ect to select an item. + 'All choices can be combined into a single if statement. + + Dim selection As String = Console.ReadLine 'Value for selection + Console.WriteLine("A1. for 7Up") + Console.WriteLine("A2. for Fanta") + Console.WriteLine("A3. for Dr. Pepper") + Console.WriteLine("A4. for Diet Coke") + Console.ReadLine() + If selection = "A1" Then + Console.WriteLine("7up") + Console.ReadLine() + ElseIf selection = "A2" Then + Console.WriteLine("fanta") + Console.ReadLine() + ElseIf selection = "A3" Then + Console.WriteLine("dr. pepper") + Console.ReadLine() + ElseIf selection = "A4" Then + Console.WriteLine("diet coke") + Console.ReadLine() + Else + Console.WriteLine("Please select a product") + Console.ReadLine() + End If + + End Sub + +End Module + +``` + +## References + +I learnt Visual Basic in the console application. It allowed me to understand the principles of computer programming to go on to learn other programming languages easily. + +I created a more indepth <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic tutorial</a> for those who would like to learn more. + +The entire syntax is valid. Copy the and paste in to the Visual Basic compiler and run (F5) the program. diff --git a/whip.html.markdown b/whip.html.markdown new file mode 100644 index 00000000..3faee98a --- /dev/null +++ b/whip.html.markdown @@ -0,0 +1,238 @@ +--- +language: whip +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +author: Tenor Biel +author_url: http://github.com/L8D +filename: whip.lisp +--- + +Whip is a LISP-dialect made for scripting and simplified concepts. +It has also borrowed a lot of functions and syntax from Haskell(a non-related language). + +These docs were written by the creator of the language himself. So is this line. + +```scheme +; Comments are like LISP. Semi-colons... + +; Majority of first-level statements are inside "forms" +; which are just things inside parens separated by whitespace +not_in_form +(in_form) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 1. Numbers, Strings, and Operators + +; Whip has one number type (which is a 64-bit IEEE 754 double, from JavaScript). +3 ; => 3 +1.5 ; => 1.5 + +; Functions are called if they are the first element in a form +(called_function args) + +; Majority of operations are done with functions +; All the basic arithmetic is pretty straight forward +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 +; even modulo +(% 9 4) ; => 1 +; JavaScript-style uneven division. +(/ 5 2) ; => 2.5 + +; Nesting forms works as you expect. +(* 2 (+ 1 3)) ; => 8 + +; There's a boolean type. +true +false + +; Strings are created with ". +"Hello, world" + +; Single chars are created with '. +'a' + +; Negation uses the 'not' function. +(not true) ; => false +(not false) ; => true + +; But the majority of non-haskell functions have shortcuts +; not's shortcut is a '!'. +(! (! true)) ; => true + +; Equality is `equal` or `=`. +(= 1 1) ; => true +(equal 2 1) ; => false + +; For example, inequality would be combining the not and equal functions. +(! (= 2 1)) ; => true + +; More comparisons +(< 1 10) ; => true +(> 1 10) ; => false +; and their word counterpart. +(lesser 1 10) ; => true +(greater 1 10) ; => false + +; Strings can be concatenated with +. +(+ "Hello " "world!") ; => "Hello world!" + +; You can use JavaScript's comparative abilities. +(< 'a' 'b') ; => true +; ...and type coercion +(= '5' 5) + +; The `at` or @ function will access characters in strings, starting at 0. +(at 0 'a') ; => 'a' +(@ 3 "foobar") ; => 'b' + +; There is also the `null` and `undefined` variables. +null ; used to indicate a deliberate non-value +undefined ; user to indicate a value that hasn't been set + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 2. Vairbles, Lists, and Dicts + +; Variables are declared with the `def` or `let` functions. +; Variables that haven't been set will be `undefined`. +(def some_var 5) +; `def` will keep the variable in the global context. +; `let` will only have the variable inside its context, and has a wierder syntax. +(let ((a_var 5)) (+ a_var 5)) ; => 10 +(+ a_var 5) ; = undefined + 5 => undefined + +; Lists are arrays of values of any type. +; They basically are just forms without functions at the beginning. +(1 2 3) ; => [1, 2, 3] (JavaScript syntax) + +; Dictionaries are Whip's equivalent to JavaScript 'objects' or Python 'dicts' +; or Ruby 'hashes': an unordered collection of key-value pairs. +{"key1" "value1" "key2" 2 3 3} + +; Keys are just values, either identifier, number, or string. +(def my_dict {my_key "my_value" "my other key" 4}) +; But in Whip, dictionaries get parsed like: value, whitespace, value; +; with more whitespace between each. So that means +{"key" "value" +"another key" +1234 +} +; is evaluated to the same as +{"key" "value" "another key" 1234} + +; Dictionary definitions can be accessed used the `at` function +; (like strings and lists.) +(@ "my other key" my_dict) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 3. Logic and Control sequences + +; The `if` function is pretty simple, though different than most imperative langs. +(if true "returned if first arg is true" "returned if first arg is false") +; => "returned if first arg is true" + +; And for the sake of ternary operator legacy +; `?` is if's unused shortcut. +(? false true false) ; => false + +; `both` is a logical 'and' statement, and `either` is a logical 'or'. +(both true true) ; => true +(both true false) ; => false +(either true false) ; => true +(either false false) ; => false +; And their shortcuts are +; & => both +; ^ => either +(& true true) ; => true +(^ false true) ; => true + +;;;;;;;;; +; Lambdas + +; Lambdas in Whip are declared with the `lambda` or `->` function. +; And functions are really just lambdas with names. +(def my_function (-> (x y) (+ (+ x y) 10))) +; | | | | +; | | | returned value(with scope containing argument vars) +; | | arguments +; | lambda declaration function +; | +; name of the to-be-declared lambda + +(my_function 10 10) ; = (+ (+ 10 10) 10) => 30 + +; Obiously, all lambdas by definition are anonymous and +; technically always used anonymously. Redundancy. +((lambda (x) x) 10) ; => 10 + +;;;;;;;;;;;;;;;; +; Comprehensions + +; `range` or `..` generates a list of numbers for +; each number between it's two args. +(range 1 5) ; => (1 2 3 4 5) +(.. 0 2) ; => (0 1 2) + +; `map` applies it's first arg(which should be a lambda/function) +; to each item in the following arg(which should be a list) +(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4) + +; Reduce +(reduce + (.. 1 5)) +; equivalent to +((+ (+ (+ 1 2) 3) 4) 5) + +; Note: map and reduce don't have shortcuts + +; `slice` or `\` is just like JavaScript's .slice() +; But do note, it takes the list as the first argument, not the last. +(slice (.. 1 5) 2) ; => (3 4 5) +(\ (.. 0 100) -5) ; => (96 97 98 99 100) + +; `append` or `<<` is self expanatory +(append 4 (1 2 3)) ; => (1 2 3 4) +(<< "bar" ("foo")) ; => ("foo" "bar") + +; Length is self explanatory. +(length (1 2 3)) ; => 3 +(_ "foobar") ; => 6 + +;;;;;;;;;;;;;;; +; Haskell fluff + +; First item in list +(head (1 2 3)) ; => 1 +; List from second to last elements in list +(tail (1 2 3)) ; => (2 3) +; Last item in list +(last (1 2 3)) ; => 3 +; Reverse of `tail` +(init (1 2 3)) ; => (1 2) +; List from first to specified elements in list +(take 1 (1 2 3 4)) ; (1 2) +; Reverse of `take` +(drop 1 (1 2 3 4)) ; (3 4) +; Lowest value in list +(min (1 2 3 4)) ; 1 +; Highest value in list +(max (1 2 3 4)) ; 4 +; If value is in list or object +(elem 1 (1 2 3)) ; true +(elem "foo" {"foo" "bar"}) ; true +(elem "bar" {"foo" "bar"}) ; false +; Reverse list order +(reverse (1 2 3 4)) ; => (4 3 2 1) +; If value is even or odd +(even 1) ; => false +(odd 1) ; => true +; Split string into list of strings by whitespace +(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese") +; Join list of strings together. +(unwords ("foo" "bar")) ; => "foobar" +(pred 21) ; => 20 +(succ 20) ; => 21 +``` + +For more info, check out the [repo](http://github.com/L8D/whip) diff --git a/xml.html.markdown b/xml.html.markdown new file mode 100644 index 00000000..d407512d --- /dev/null +++ b/xml.html.markdown @@ -0,0 +1,127 @@ +--- +language: xml +filename: learnxml.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +--- + +XML is a markup language designed to store and transport data. + +Unlike HTML, XML does not specify how to display or to format data, just carry it. + +* XML Syntax + +```xml +<!-- Comments in XML are like this --> + +<?xml version="1.0" encoding="UTF-8"?> +<bookstore> + <book category="COOKING"> + <title lang="en">Everyday Italian</title> + <author>Giada De Laurentiis</author> + <year>2005</year> + <price>30.00</price> + </book> + <book category="CHILDREN"> + <title lang="en">Harry Potter</title> + <author>J K. Rowling</author> + <year>2005</year> + <price>29.99</price> + </book> + <book category="WEB"> + <title lang="en">Learning XML</title> + <author>Erik T. Ray</author> + <year>2003</year> + <price>39.95</price> + </book> +</bookstore> + +<!-- Above is a typical XML file. + It starts with a declaration, informing some metadata (optional). + + XML uses a tree structure. Above, the root node is 'bookstore', which has + three child nodes, all 'books'. Those nodes has more child nodes, and so on... + + Nodes are created using open/close tags, and childs are just nodes between + the open and close tags.--> + + +<!-- XML carries two kind of data: + 1 - Attributes -> That's metadata about a node. + Usually, the XML parser uses this information to store the data properly. + It is characterized by appearing with the format name="value" within the opening + tag. + 2 - Elements -> That's pure data. + That's what the parser will retrieve from the XML file. + Elements appear between the open and close tags. --> + + +<!-- Below, an element with two attributes --> +<file type="gif" id="4293">computer.gif</file> + + +``` + +* Well-Formated Document x Validation + +A XML document is well-formated if it is syntactically correct. +However, it is possible to inject more constraints in the document, +using document definitions, such as DTD and XML Schema. + +A XML document which follows a document definition is called valid, +regarding that document. + +With this tool, you can check the XML data outside the application logic. + +```xml + +<!-- Below, you can see an simplified version of bookstore document, + with the addition of DTD definition.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Bookstore.dtd"> +<bookstore> + <book category="COOKING"> + <title >Everyday Italian</title> + <price>30.00</price> + </book> +</bookstore> + +<!-- This DTD could be something like:--> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Literature"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + + +<!-- The DTD starts with a declaration. + Following, the root node is declared, requiring 1 or more child nodes 'book'. + Each 'book' should contain exactly one 'title' and 'price' and an attribute + called 'category', with "Literature" as its default value. + The 'title' and 'price' nodes contain a parsed character data.--> + +<!-- The DTD could be declared inside the XML file itself.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Literature"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + +<bookstore> + <book category="COOKING"> + <title >Everyday Italian</title> + <price>30.00</price> + </book> +</bookstore> +``` diff --git a/yaml.html.markdown b/yaml.html.markdown new file mode 100644 index 00000000..6e3e2c94 --- /dev/null +++ b/yaml.html.markdown @@ -0,0 +1,139 @@ +--- +language: yaml +filename: learnyaml.yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +--- + +YAML is a data serialisation language designed to be directly writable and +readable by humans. + +It's a strict superset of JSON, with the addition of syntactically +significant newlines and indentation, like Python. Unlike Python, however, +YAML doesn't allow literal tab characters at all. + +```yaml +# Comments in YAML look like this. + +################ +# SCALAR TYPES # +################ + +# Our root object (which continues for the entire document) will be a map, +# which is equivalent to a dictionary, hash or object in other languages. +key: value +another_key: Another value goes here. +a_number_value: 100 +scientific_notation: 1e+12 +boolean: true +null_value: null +key with spaces: value +# Notice that strings don't need to be quoted. However, they can be. +however: "A string, enclosed in quotes." +"Keys can be quoted too.": "Useful if you want to put a ':' in your key." + +# Multiple-line strings can be written either as a 'literal block' (using |), +# or a 'folded block' (using '>'). +literal_block: | + This entire block of text will be the value of the 'literal_block' key, + with line breaks being preserved. + + The literal continues until de-dented, and the leading indentation is + stripped. + + Any lines that are 'more-indented' keep the rest of their indentation - + these lines will be indented by 4 spaces. +folded_style: > + This entire block of text will be the value of 'folded_style', but this + time, all newlines will be replaced with a single space. + + Blank lines, like above, are converted to a newline character. + + 'More-indented' lines keep their newlines, too - + this text will appear over two lines. + +#################### +# COLLECTION TYPES # +#################### + +# Nesting is achieved by indentation. +a_nested_map: + key: value + another_key: Another Value + another_nested_map: + hello: hello + +# Maps don't have to have string keys. +0.25: a float key + +# Keys can also be multi-line objects, using ? to indicate the start of a key. +? | + This is a key + that has multiple lines +: and this is its value + +# YAML also allows collection types in keys, but many programming languages +# will complain. + +# Sequences (equivalent to lists or arrays) look like this: +a_sequence: + - Item 1 + - Item 2 + - 0.5 # sequences can contain disparate types. + - Item 4 + - key: value + another_key: another_value + - + - This is a sequence + - inside another sequence + +# Since YAML is a superset of JSON, you can also write JSON-style maps and +# sequences: +json_map: {"key": "value"} +json_seq: [3, 2, 1, "takeoff"] + +####################### +# EXTRA YAML FEATURES # +####################### + +# YAML also has a handy feature called 'anchors', which let you easily duplicate +# content across your document. Both of these keys will have the same value: +anchored_content: &anchor_name This string will appear as the value of two keys. +other_anchor: *anchor_name + +# YAML also has tags, which you can use to explicitly declare types. +explicit_string: !!str 0.5 +# Some parsers implement language specific tags, like this one for Python's +# complex number type. +python_complex_number: !!python/complex 1+2j + +#################### +# EXTRA YAML TYPES # +#################### + +# Strings and numbers aren't the only scalars that YAML can understand. +# ISO-formatted date and datetime literals are also parsed. +datetime: 2001-12-15T02:59:43.1Z +datetime_with_spaces: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 + +# The !!binary tag indicates that a string is actually a base64-encoded +# representation of a binary blob. +gif_file: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML also has a set type, which looks like this: +set: + ? item1 + ? item2 + ? item3 + +# Like Python, sets are just maps with null values; the above is equivalent to: +set2: + item1: null + item2: null + item3: null +``` diff --git a/zh-cn/bash-cn.html.markdown b/zh-cn/bash-cn.html.markdown new file mode 100644 index 00000000..d85e5b8f --- /dev/null +++ b/zh-cn/bash-cn.html.markdown @@ -0,0 +1,277 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] + - ["Etan Reisner", "https://github.com/deryni"] +translators: + - ["Jinchang Ye", "https://github.com/Alwayswithme"] + - ["Chunyang Xu", "https://github.com/XuChunyang"] +filename: LearnBash-cn.sh +lang: zh-cn +--- + +Bash 是一个为 GNU 计划编写的 Unix shell，是 Linux 和 Mac OS X 下的默认 shell。 +以下大多数例子可以作为脚本的一部分运行，也可直接在 shell 下交互执行。 + +[更多信息](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# 脚本的第一行叫 shebang，用来告知系统如何执行该脚本: +# 参见： http://en.wikipedia.org/wiki/Shebang_(Unix) +# 如你所见，注释以 # 开头，shebang 也是注释。 + +# 显示 “Hello world!” +echo Hello world! + +# 每一句指令以换行或分号隔开： +echo 'This is the first line'; echo 'This is the second line' + +# 声明一个变量： +Variable="Some string" + +# 下面是错误的做法： +Variable = "Some string" +# Bash 会把 Variable 当做一个指令，由于找不到该指令，因此这里会报错。 + +# 也不可以这样： +Variable= 'Some string' +# Bash 会认为 'Some string' 是一条指令，由于找不到该指令，这里再次报错。 +# （这个例子中 'Variable=' 这部分会被当作仅对 'Some string' 起作用的赋值。） + +# 使用变量： +echo $Variable +echo "$Variable" +echo '$Variable' +# 当你赋值 (assign) 、导出 (export)，或者以其他方式使用变量时，变量名前不加 $。 +# 如果要使用变量的值， 则要加 $。 +# 注意： ' (单引号) 不会展开变量（即会屏蔽掉变量）。 + + +# 在变量内部进行字符串代换 +echo ${Variable/Some/A} +# 会把 Variable 中首次出现的 "some" 替换成 “A”。 + +# 变量的截取 +Length=7 +echo ${Variable:0:Length} +# 这样会仅返回变量值的前7个字符 + +# 变量的默认值 +echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"} +# 对 null (Foo=) 和空串 (Foo="") 起作用； 零（Foo=0）时返回0 +# 注意这仅返回默认值而不是改变变量的值 + +# 内置变量： +# 下面的内置变量很有用 +echo "Last program return value: $?" +echo "Script's PID: $$" +echo "Number of arguments: $#" +echo "Scripts arguments: $@" +echo "Scripts arguments separated in different variables: $1 $2..." + +# 读取输入： +echo "What's your name?" +read Name # 这里不需要声明新变量 +echo Hello, $Name! + +# 通常的 if 结构看起来像这样： +# 'man test' 可查看更多的信息 +if [ $Name -ne $USER ] +then + echo "Your name isn't your username" +else + echo "Your name is your username" +fi + +# 根据上一个指令执行结果决定是否执行下一个指令 +echo "Always executed" || echo "Only executed if first command fails" +echo "Always executed" && echo "Only executed if first command does NOT fail" + +# 在 if 语句中使用 && 和 || 需要多对方括号 +if [ $Name == "Steve" ] && [ $Age -eq 15 ] +then + echo "This will run if $Name is Steve AND $Age is 15." +fi + +if [ $Name == "Daniya" ] || [ $Name == "Zach" ] +then + echo "This will run if $Name is Daniya OR Zach." +fi + +# 表达式的格式如下: +echo $(( 10 + 5 )) + +# 与其他编程语言不同的是，bash 运行时依赖上下文。比如，使用 ls 时，列出当前目录。 +ls + +# 指令可以带有选项： +ls -l # 列出文件和目录的详细信息 + +# 前一个指令的输出可以当作后一个指令的输入。grep 用来匹配字符串。 +# 用下面的指令列出当前目录下所有的 txt 文件： +ls -l | grep "\.txt" + +# 重定向输入和输出（标准输入，标准输出，标准错误）。 +# 以 ^EOF$ 作为结束标记从标准输入读取数据并覆盖 hello.py : +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# 重定向可以到输出，输入和错误输出。 +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# > 会覆盖已存在的文件， >> 会以累加的方式输出文件中。 +python hello.py >> "output.out" 2>> "error.err" + +# 覆盖 output.out , 追加 error.err 并统计行数 +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# 运行指令并打印文件描述符 （比如 /dev/fd/123） +# 具体可查看： man fd +echo <(echo "#helloworld") + +# 以 "#helloworld" 覆盖 output.out: +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# 清理临时文件并显示详情（增加 '-i' 选项启用交互模式） +rm -v output.out error.err output-and-error.log + +# 一个指令可用 $( ) 嵌套在另一个指令内部： +# 以下的指令会打印当前目录下的目录和文件总数 +echo "There are $(ls | wc -l) items here." + +# 反引号 `` 起相同作用，但不允许嵌套 +# 优先使用 $( ). +echo "There are `ls | wc -l` items here." + +# Bash 的 case 语句与 Java 和 C++ 中的 switch 语句类似: +case "$Variable" in + # 列出需要匹配的字符串 + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# 循环遍历给定的参数序列: +# 变量$Variable 的值会被打印 3 次。 +for Variable in {1..3} +do + echo "$Variable" +done + +# 或传统的 “for循环” ： +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# 也可以用于文件 +# 用 cat 输出 file1 和 file2 内容 +for Variable in file1 file2 +do + cat "$Variable" +done + +# 或作用于其他命令的输出 +# 对 ls 输出的文件执行 cat 指令。 +for Output in $(ls) +do + cat "$Output" +done + +# while 循环： +while [ true ] +do + echo "loop body here..." + break +done + +# 你也可以使用函数 +# 定义函数： +function foo () +{ + echo "Arguments work just like script arguments: $@" + echo "And: $1 $2..." + echo "This is a function" + return 0 +} + +# 更简单的方法 +bar () +{ + echo "Another way to declare functions!" + return 0 +} + +# 调用函数 +foo "My name is" $Name + +# 有很多有用的指令需要学习: +# 打印 file.txt 的最后 10 行 +tail -n 10 file.txt +# 打印 file.txt 的前 10 行 +head -n 10 file.txt +# 将 file.txt 按行排序 +sort file.txt +# 报告或忽略重复的行，用选项 -d 打印重复的行 +uniq -d file.txt +# 打印每行中 ',' 之前内容 +cut -d ',' -f 1 file.txt +# 将 file.txt 文件所有 'okay' 替换为 'great', （兼容正则表达式） +sed -i 's/okay/great/g' file.txt +# 将 file.txt 中匹配正则的行打印到标准输出 +# 这里打印以 "foo" 开头, "bar" 结尾的行 +grep "^foo.*bar$" file.txt +# 使用选项 "-c" 统计行数 +grep -c "^foo.*bar$" file.txt +# 如果只是要按字面形式搜索字符串而不是按正则表达式，使用 fgrep (或 grep -F) +fgrep "^foo.*bar$" file.txt + + +# 以 bash 内建的 'help' 指令阅读 Bash 自带文档： +help +help help +help for +help return +help source +help . + +# 用 man 指令阅读相关的 Bash 手册 +apropos bash +man 1 bash +man bash + +# 用 info 指令查阅命令的 info 文档 （info 中按 ? 显示帮助信息） +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# 阅读 Bash 的 info 文档： +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/zh-cn/brainfuck-cn.html.markdown b/zh-cn/brainfuck-cn.html.markdown new file mode 100644 index 00000000..a6f3fa09 --- /dev/null +++ b/zh-cn/brainfuck-cn.html.markdown @@ -0,0 +1,70 @@ +--- +language: brainfuck +lang: zh-cn +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["lyuehh", "https://github.com/lyuehh"] +--- + +Brainfuck 是一个极小的只有8个指令的图灵完全的编程语言。 + +``` +除"><+-.,[]"之外的的任何字符都会被忽略 (不包含双引号)。 + +Brainfuck 包含一个有30,000个单元为0的数组，和 +一个数据指针指向当前的单元。 + +8个指令如下: ++ : 指针指向的单元的值加1 +- : 指针指向的单元的值减1 +> : 将指针移动到下一个单元(右边的元素) +< : 将指针移动到上一个单元(左边的元素) +. : 打印当前单元的内容的ASCII值 (比如 65 = 'A'). +, : 读取一个字符到当前的单元 +[ : 如果当前单元的值是0，则向后调转到对应的]处 +] : 如果当前单元的值不是0，则向前跳转到对应的[处 + +[ 和 ] 组成了一个while循环。很明显，它们必须配对。 + +让我们看一些基本的brainfuck 程序。 + +++++++ [ > ++++++++++ < - ] > +++++ . + +这个程序打印字母'A'。首先，它把 #1 增加到6，使用它来作为循环条件， +然后，进入循环，将指针移动到 #2 ，将 #2 的值增加到10，然后 +移动回 #1，将单元 #1 的值减1，然后继续。循环共进行了6次。 + +这时，我们在 #1，它的值为0，#2 的值为60，我们移动到 +#2，将 #2 的内容加上5，然后将 #2 的内容打印出来，65在 +ASCII中表示'A', 所以'A'就会被打印出来。 + + +, [ > + < - ] > . + +这个程序从用户的输入中读取一个字符，然后把它复制到 #1。 +然后我们开始一个循环，移动到 #2，将 #2 的值加1，再移动回 #1，将 #1 +的值减1，直到 #1的值为0，这样 #2 里就保存了 #1 的旧值，循环结束时我们 +在 #1，这时我们移动到 #2，然后把字符以ASCII打印出来。 + +而且要记住的一点就是，空格在这里只是为了可读性，你可以将他们写成这样: + +,[>+<-]>. + +试着思考一下这段程序是干什么的: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +这段程序从输入接收2个参数，然后将他们相乘。 + +先读取2个输入，然后开始外层循环，以 #1 作为终止条件，然后将指针移动到 +#2，然后开始 #2 的内层循环，将 #3 加1。但是这里有一个小问题，在内层 +循环结束的时候，#2 的值是0了，那么下次执行外层循环的时候，就有问题了。 +为了解决这个问题，我们可以增加 #4 的值，然后把 #4 的值复制到 #2， +最后结果就保存在 #3 中了。 +``` +好了这就是brainfuck了。也没那么难，是吧？为了好玩，你可以写你自己的 +brainfuck程序，或者用其他语言写一个brainfuck的解释器，解释器非常容易 +实现，但是如果你是一个自虐狂的话，你可以尝试用brainfuck写一个brainfuk的 +解释器。 diff --git a/zh-cn/c++-cn.html.markdown b/zh-cn/c++-cn.html.markdown new file mode 100644 index 00000000..e1551e2b --- /dev/null +++ b/zh-cn/c++-cn.html.markdown @@ -0,0 +1,572 @@ +---
+language: c++
+filename: learncpp-cn.cpp
+contributors:
+ - ["Steven Basart", "http://github.com/xksteven"]
+ - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+ - ["Arnie97", "https://github.com/Arnie97"]
+lang: zh-cn
+---
+
+C++是一种系统编程语言。用它的发明者，
+[Bjarne Stroustrup的话](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote)来说，C++的设计目标是：
+
+- 成为“更好的C语言”
+- 支持数据的抽象与封装
+- 支持面向对象编程
+- 支持泛型编程
+
+C++提供了对硬件的紧密控制（正如C语言一样），
+能够编译为机器语言，由处理器直接执行。
+与此同时，它也提供了泛型、异常和类等高层功能。
+虽然C++的语法可能比某些出现较晚的语言更复杂，它仍然得到了人们的青睞——
+功能与速度的平衡使C++成为了目前应用最广泛的系统编程语言之一。
+
+```c++
+////////////////
+// 与C语言的比较
+////////////////
+
+// C++_几乎_是C语言的一个超集，它与C语言的基本语法有许多相同之处，
+// 例如变量和函数的声明，原生数据类型等等。
+
+// 和C语言一样，在C++中，你的程序会从main()开始执行，
+// 该函数的返回值应当为int型，这个返回值会作为程序的退出状态值。
+// 不过，大多数的编译器（gcc，clang等）也接受 void main() 的函数原型。
+// （参见 http://en.wikipedia.org/wiki/Exit_status 来获取更多信息）
+int main(int argc, char** argv)
+{
+ // 和C语言一样，命令行参数通过argc和argv传递。
+ // argc代表命令行参数的数量，
+ // 而argv是一个包含“C语言风格字符串”（char *）的数组，
+ // 其中每个字符串代表一个命令行参数的内容，
+ // 首个命令行参数是调用该程序时所使用的名称。
+ // 如果你不关心命令行参数的值，argc和argv可以被忽略。
+ // 此时，你可以用int main()作为函数原型。
+
+ // 退出状态值为0时，表示程序执行成功
+ return 0;
+}
+
+// 然而，C++和C语言也有一些区别：
+
+// 在C++中，字符字面量的大小是一个字节。
+sizeof('c') == 1
+
+// 在C语言中，字符字面量的大小与int相同。
+sizeof('c') == sizeof(10)
+
+
+// C++的函数原型与函数定义是严格匹配的
+void func(); // 这个函数不能接受任何参数
+
+// 而在C语言中
+void func(); // 这个函数能接受任意数量的参数
+
+// 在C++中，用nullptr代替C语言中的NULL
+int* ip = nullptr;
+
+// C++也可以使用C语言的标准头文件，
+// 但是需要加上前缀“c”并去掉末尾的“.h”。
+#include <cstdio>
+
+int main()
+{
+ printf("Hello, world!\n");
+ return 0;
+}
+
+///////////
+// 函数重载
+///////////
+
+// C++支持函数重载，你可以定义一组名称相同而参数不同的函数。
+
+void print(char const* myString)
+{
+ printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+ printf("My int is %d", myInt);
+}
+
+int main()
+{
+ print("Hello"); // 解析为 void print(const char*)
+ print(15); // 解析为 void print(int)
+}
+
+///////////////////
+// 函数参数的默认值
+///////////////////
+
+// 你可以为函数的参数指定默认值，
+// 它们将会在调用者没有提供相应参数时被使用。
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+ // 对两个参数进行一些操作
+}
+
+int main()
+{
+ doSomethingWithInts(); // a = 1, b = 4
+ doSomethingWithInts(20); // a = 20, b = 4
+ doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// 默认参数必须放在所有的常规参数之后。
+
+void invalidDeclaration(int a = 1, int b) // 这是错误的！
+{
+}
+
+
+///////////
+// 命名空间
+///////////
+
+// 命名空间为变量、函数和其他声明提供了分离的的作用域。
+// 命名空间可以嵌套使用。
+
+namespace First {
+ namespace Nested {
+ void foo()
+ {
+ printf("This is First::Nested::foo\n");
+ }
+ } // 结束嵌套的命名空间Nested
+} // 结束命名空间First
+
+namespace Second {
+ void foo()
+ {
+ printf("This is Second::foo\n")
+ }
+}
+
+void foo()
+{
+ printf("This is global foo\n");
+}
+
+int main()
+{
+ // 如果没有特别指定，就从“Second”中取得所需的内容。
+ using namespace Second;
+
+ foo(); // 显示“This is Second::foo”
+ First::Nested::foo(); // 显示“This is First::Nested::foo”
+ ::foo(); // 显示“This is global foo”
+}
+
+////////////
+// 输入/输出
+////////////
+
+// C++使用“流”来输入输出。<<是流的插入运算符，>>是流提取运算符。
+// cin、cout、和cerr分别代表
+// stdin（标准输入）、stdout（标准输出）和stderr（标准错误）。
+
+#include <iostream> // 引入包含输入/输出流的头文件
+
+using namespace std; // 输入输出流在std命名空间（也就是标准库）中。
+
+int main()
+{
+ int myInt;
+
+ // 在标准输出（终端/显示器）中显示
+ cout << "Enter your favorite number:\n";
+ // 从标准输入（键盘）获得一个值
+ cin >> myInt;
+
+ // cout也提供了格式化功能
+ cout << "Your favorite number is " << myInt << "\n";
+ // 显示“Your favorite number is <myInt>”
+
+ cerr << "Used for error messages";
+}
+
+/////////
+// 字符串
+/////////
+
+// C++中的字符串是对象，它们有很多成员函数
+#include <string>
+
+using namespace std; // 字符串也在std命名空间（标准库）中。
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + 可以用于连接字符串。
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// C++中的字符串是可变的，具有“值语义”。
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+/////////////
+// 引用
+/////////////
+
+// 除了支持C语言中的指针类型以外，C++还提供了_引用_。
+// 引用是一种特殊的指针类型，一旦被定义就不能重新赋值，并且不能被设置为空值。
+// 使用引用时的语法与原变量相同：
+// 也就是说，对引用类型进行解引用时，不需要使用*；
+// 赋值时也不需要用&来取地址。
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // 建立了一个对foo的引用。
+fooRef += ". Hi!"; // 通过引用来修改foo的值
+cout << fooRef; // "I am foo. Hi!"
+
+// 这句话的并不会改变fooRef的指向，其效果与“foo = bar”相同。
+// 也就是说，在执行这条语句之后，foo == "I am bar"。
+fooRef = bar;
+
+const string& barRef = bar; // 建立指向bar的常量引用。
+// 和C语言中一样，（指针和引用）声明为常量时，对应的值不能被修改。
+barRef += ". Hi!"; // 这是错误的，不能修改一个常量引用的值。
+
+///////////////////
+// 类与面向对象编程
+///////////////////
+
+// 有关类的第一个示例
+#include <iostream>
+
+// 声明一个类。
+// 类通常在头文件（.h或.hpp）中声明。
+class Dog {
+ // 成员变量和成员函数默认情况下是私有（private）的。
+ std::string name;
+ int weight;
+
+// 在这个标签之后，所有声明都是公有（public）的，
+// 直到重新指定“private:”（私有继承）或“protected:”（保护继承）为止
+public:
+
+ // 默认的构造器
+ Dog();
+
+ // 这里是成员函数声明的一个例子。
+ // 可以注意到，我们在此处使用了std::string，而不是using namespace std
+ // 语句using namespace绝不应当出现在头文件当中。
+ void setName(const std::string& dogsName);
+
+ void setWeight(int dogsWeight);
+
+ // 如果一个函数不对对象的状态进行修改，
+ // 应当在声明中加上const。
+ // 这样，你就可以对一个以常量方式引用的对象执行该操作。
+ // 同时可以注意到，当父类的成员函数需要被子类重写时，
+ // 父类中的函数必须被显式声明为_虚函数（virtual）_。
+ // 考虑到性能方面的因素，函数默认情况下不会被声明为虚函数。
+ virtual void print() const;
+
+ // 函数也可以在class body内部定义。
+ // 这样定义的函数会自动成为内联函数。
+ void bark() const { std::cout << name << " barks!\n" }
+
+ // 除了构造器以外，C++还提供了析构器。
+ // 当一个对象被删除或者脱离其定义域时，它的析构函数会被调用。
+ // 这使得RAII这样的强大范式（参见下文）成为可能。
+ // 为了衍生出子类来，基类的析构函数必须定义为虚函数。
+ virtual ~Dog();
+
+}; // 在类的定义之后，要加一个分号
+
+// 类的成员函数通常在.cpp文件中实现。
+void Dog::Dog()
+{
+ std::cout << "A dog has been constructed\n";
+}
+
+// 对象（例如字符串）应当以引用的形式传递，
+// 对于不需要修改的对象，最好使用常量引用。
+void Dog::setName(const std::string& dogsName)
+{
+ name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+ weight = dogsWeight;
+}
+
+// 虚函数的virtual关键字只需要在声明时使用，不需要在定义时重复
+void Dog::print() const
+{
+ std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+void Dog::~Dog()
+{
+ cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+ Dog myDog; // 此时显示“A dog has been constructed”
+ myDog.setName("Barkley");
+ myDog.setWeight(10);
+ myDog.printDog(); // 显示“Dog is Barkley and weighs 10 kg”
+ return 0;
+} // 显示“Goodbye Barkley”
+
+// 继承：
+
+// 这个类继承了Dog类中的公有（public）和保护（protected）对象
+class OwnedDog : public Dog {
+
+ void setOwner(const std::string& dogsOwner)
+
+ // 重写OwnedDogs类的print方法。
+ // 如果你不熟悉子类多态的话，可以参考这个页面中的概述：
+ // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B
+
+ // override关键字是可选的，它确保你所重写的是基类中的方法。
+ void print() const override;
+
+private:
+ std::string owner;
+};
+
+// 与此同时，在对应的.cpp文件里：
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+ owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+ Dog::print(); // 调用基类Dog中的print方法
+ // "Dog is <name> and weights <weight>"
+
+ std::cout << "Dog is owned by " << owner << "\n";
+ // "Dog is owned by <owner>"
+}
+
+/////////////////////
+// 初始化与运算符重载
+/////////////////////
+
+// 在C++中，通过定义一些特殊名称的函数，
+// 你可以重载+、-、*、/等运算符的行为。
+// 当运算符被使用时，这些特殊函数会被调用，从而实现运算符重载。
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+ // 可以以这样的方式为成员变量设置默认值。
+ double x = 0;
+ double y = 0;
+
+ // 定义一个默认的构造器。
+ // 除了将Point初始化为(0, 0)以外，这个函数什么都不做。
+ Point() { };
+
+ // 下面使用的语法称为初始化列表，
+ // 这是初始化类中成员变量的正确方式。
+ Point (double a, double b) :
+ x(a),
+ y(b)
+ { /* 除了初始化成员变量外，什么都不做 */ }
+
+ // 重载 + 运算符
+ Point operator+(const Point& rhs) const;
+
+ // 重载 += 运算符
+ Point& operator+=(const Point& rhs);
+
+ // 增加 - 和 -= 运算符也是有意义的，但这里不再赘述。
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+ // 创建一个新的点，
+ // 其横纵坐标分别为这个点与另一点在对应方向上的坐标之和。
+ return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+ x += rhs.x;
+ y += rhs.y;
+ return *this;
+}
+
+int main () {
+ Point up (0,1);
+ Point right (1,0);
+ // 这里使用了Point类型的运算符“+”
+ // 调用up（Point类型）的“+”方法，并以right作为函数的参数
+ Point result = up + right;
+ // 显示“Result is upright (1,1)”
+ cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+ return 0;
+}
+
+///////////
+// 异常处理
+///////////
+
+// 标准库中提供了一些基本的异常类型
+// （参见http://en.cppreference.com/w/cpp/error/exception）
+// 但是，其他任何类型也可以作为一个异常被拋出
+#include <exception>
+
+// 在_try_代码块中拋出的异常可以被随后的_catch_捕获。
+try {
+ // 不要用 _new_关键字在堆上为异常分配空间。
+ throw std::exception("A problem occurred");
+}
+// 如果拋出的异常是一个对象，可以用常量引用来捕获它
+catch (const std::exception& ex)
+{
+ std::cout << ex.what();
+// 捕获尚未被_catch_处理的所有错误
+} catch (...)
+{
+ std::cout << "Unknown exception caught";
+ throw; // 重新拋出异常
+}
+
+///////
+// RAII
+///////
+
+// RAII指的是“资源获取就是初始化”（Resource Allocation Is Initialization），
+// 它被视作C++中最强大的编程范式之一。
+// 简单说来，它指的是，用构造函数来获取一个对象的资源，
+// 相应的，借助析构函数来释放对象的资源。
+
+// 为了理解这一范式的用处，让我们考虑某个函数使用文件句柄时的情况：
+void doSomethingWithAFile(const char* filename)
+{
+ // 首先，让我们假设一切都会顺利进行。
+
+ FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
+
+ doSomethingWithTheFile(fh);
+ doSomethingElseWithIt(fh);
+
+ fclose(fh); // 关闭文件句柄
+}
+
+// 不幸的是，随着错误处理机制的引入，事情会变得复杂。
+// 假设fopen函数有可能执行失败，
+// 而doSomethingWithTheFile和doSomethingElseWithIt会在失败时返回错误代码。
+// （虽然异常是C++中处理错误的推荐方式，
+// 但是某些程序员，尤其是有C语言背景的，并不认可异常捕获机制的作用）。
+// 现在，我们必须检查每个函数调用是否成功执行，并在问题发生的时候关闭文件句柄。
+bool doSomethingWithAFile(const char* filename)
+{
+ FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
+ if (fh == nullptr) // 当执行失败是，返回的指针是nullptr
+ return false; // 向调用者汇报错误
+
+ // 假设每个函数会在执行失败时返回false
+ if (!doSomethingWithTheFile(fh)) {
+ fclose(fh); // 关闭文件句柄，避免造成内存泄漏。
+ return false; // 反馈错误
+ }
+ if (!doSomethingElseWithIt(fh)) {
+ fclose(fh); // 关闭文件句柄
+ return false; // 反馈错误
+ }
+
+ fclose(fh); // 关闭文件句柄
+ return true; // 指示函数已成功执行
+}
+
+// C语言的程序员通常会借助goto语句简化上面的代码：
+bool doSomethingWithAFile(const char* filename)
+{
+ FILE* fh = fopen(filename, "r");
+ if (fh == nullptr)
+ return false;
+
+ if (!doSomethingWithTheFile(fh))
+ goto failure;
+
+ if (!doSomethingElseWithIt(fh))
+ goto failure;
+
+ fclose(fh); // 关闭文件
+ return true; // 执行成功
+
+failure:
+ fclose(fh);
+ return false; // 反馈错误
+}
+
+// 如果用异常捕获机制来指示错误的话，
+// 代码会变得清晰一些，但是仍然有优化的余地。
+void doSomethingWithAFile(const char* filename)
+{
+ FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
+ if (fh == nullptr)
+ throw std::exception("Could not open the file.");
+
+ try {
+ doSomethingWithTheFile(fh);
+ doSomethingElseWithIt(fh);
+ }
+ catch (...) {
+ fclose(fh); // 保证出错的时候文件被正确关闭
+ throw; // 之后，重新抛出这个异常
+ }
+
+ fclose(fh); // 关闭文件
+ // 所有工作顺利完成
+}
+
+// 相比之下，使用C++中的文件流类（fstream）时，
+// fstream会利用自己的析构器来关闭文件句柄。
+// 只要离开了某一对象的定义域，它的析构函数就会被自动调用。
+void doSomethingWithAFile(const std::string& filename)
+{
+ // ifstream是输入文件流（input file stream）的简称
+ std::ifstream fh(filename); // 打开一个文件
+
+ // 对文件进行一些操作
+ doSomethingWithTheFile(fh);
+ doSomethingElseWithIt(fh);
+
+} // 文件已经被析构器自动关闭
+
+// 与上面几种方式相比，这种方式有着_明显_的优势：
+// 1. 无论发生了什么情况，资源（此例当中是文件句柄）都会被正确关闭。
+// 只要你正确使用了析构器，就_不会_因为忘记关闭句柄，造成资源的泄漏。
+// 2. 可以注意到，通过这种方式写出来的代码十分简洁。
+// 析构器会在后台关闭文件句柄，不再需要你来操心这些琐事。
+// 3. 这种方式的代码具有异常安全性。
+// 无论在函数中的何处拋出异常，都不会阻碍对文件资源的释放。
+
+// 地道的C++代码应当把RAII的使用扩展到各种类型的资源上，包括：
+// - 用unique_ptr和shared_ptr管理的内存
+// - 各种数据容器，例如标准库中的链表、向量（容量自动扩展的数组）、散列表等；
+// 当它们脱离作用域时，析构器会自动释放其中储存的内容。
+// - 用lock_guard和unique_lock实现的互斥
+```
+扩展阅读：
+
+<http://cppreference.com/w/cpp> 提供了最新的语法参考。
+
+可以在 <http://cplusplus.com> 找到一些补充资料。
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown index ed55203c..1e10416e 100755..100644 --- a/zh-cn/c-cn.html.markdown +++ b/zh-cn/c-cn.html.markdown @@ -1,40 +1,56 @@ --- language: c -filename: learnc.c +filename: learnc-cn.c contributors: - - ["Adam Bard", "http://adambard.com/"]
+ - ["Adam Bard", "http://adambard.com/"] translators: - - ["Chenbo Li", "http://binarythink.net/"] + - ["Chenbo Li", "http://binarythink.net/"] + - ["Jakukyo Friel", "http://weakish.github.io"] +lang: zh-cn --- C语言在今天仍然是高性能计算的主要选择。 -C大概是大多数程序员用到的最接近底层的语言了，但是C语言本身不仅可以用来提升程序运行的速度 -注意看看C语言的文档，你就会知道C语言在内存管理方面的强大也是其他语言无法比拟的。 +C大概是大多数程序员用到的最接近底层的语言了，C语言原生的速度就很高了，但是别忘了C的手动内存管理，它会让你将性能发挥到极致。 ```c -// 用“//”来实现单行注释 +// 单行注释以//开始。（仅适用于C99或更新的版本。） /* -多行注释是这个样子的 +多行注释是这个样子的。（C89也适用。） */ +// 常数： #define 关键词 +#define DAYS_IN_YEAR 365 + +// 以枚举的方式定义常数 +enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT}; +// MON自动被定义为2，TUE被定义为3，以此类推。 + // 用#include来导入头文件 #include <stdlib.h> #include <stdio.h> #include <string.h> -// 函数的标签(signature)应该放在.h文件中，并且引入到程序顶部 -// 也可以直接放到你的.c文件的最上面 -void function_1(); -void function_2(); +// <尖括号>间的文件名是C标准库的头文件。 +// 标准库以外的头文件，使用双引号代替尖括号。 +#include "my_header.h" + +// 函数的签名可以事先在.h文件中定义， +// 也可以直接在.c文件的头部定义。 +void function_1(char c); +void function_2(void); -// c程序的入口是一个返回值为int型的函数，名字叫做main +// 如果函数出现在main()之后，那么必须在main()之前 +// 先声明一个函数原型 +int add_two_ints(int x1, int x2); // 函数原型 + +// 你的程序的入口是一个返回值为整型的main函数 int main() { -// 用printf来实现标准输出，这种输出也可以用格式来控制 -// %d 代表一个整数, \n 代表一个新行 -printf("%d\n", 0); // => 输出 0 +// 用printf打印到标准输出，可以设定格式， +// %d 代表整数, \n 代表换行 +printf("%d\n", 0); // => 打印 0 // 所有的语句都要以分号结束 /////////////////////////////////////// @@ -68,18 +84,29 @@ double x_double = 0.0; // 整数类型也可以有无符号的类型表示。这样这些变量就无法表示负数 // 但是无符号整数所能表示的范围就可以比原来的整数大一些 -unsigned char ux_char; unsigned short ux_short; unsigned int ux_int; unsigned long long ux_long_long; +// 单引号内的字符是机器的字符集中的整数。 +'0' // => 在ASCII字符集中是48 +'A' // => 在ASCII字符集中是65 + // char类型一定会占用1个字节，但是其他的类型却会因具体机器的不同而各异 // sizeof(T) 可以返回T类型在运行的机器上占用多少个字节 // 这样你的代码就可以在各处正确运行了 -// 比如 -printf("%lu\n", sizeof(int)); // => 4 (字长为4的机器上) - -// 数组必须要在开始被初始化为特定的长度 +// sizeof(obj)返回表达式（变量、字面量等）的尺寸 +printf("%zu\n", sizeof(int)); // => 4 (大多数的机器字长为4) + +// 如果`sizeof`的参数是一个表达式，那么这个参数不会被演算（VLA例外，见下） +// 它产生的值是编译期的常数 +int a = 1; +// size_t是一个无符号整型，表示对象的尺寸，至少2个字节 +size_t size = sizeof(a++); // a++ 不会被演算 +printf("sizeof(a++) = %zu where a = %d\n", size, a); +// 打印 "sizeof(a++) = 4 where a = 1" （在32位架构上） + +// 数组必须要被初始化为具体的长度 char my_char_array[20]; // 这个数组占据 1 * 20 = 20 个字节 int my_int_array[20]; // 这个数组占据 4 * 20 = 80 个字节 // (这里我们假设字长为4) @@ -88,48 +115,83 @@ int my_int_array[20]; // 这个数组占据 4 * 20 = 80 个字节 // 可以用下面的方法把数组初始化为0: char my_array[20] = {0}; -// 对数组任意存取就像其他语言的方式 -- 其实是其他的语言像C +// 索引数组和其他语言类似 -- 好吧，其实是其他的语言像C my_array[0]; // => 0 // 数组是可变的，其实就是内存的映射！ my_array[1] = 2; printf("%d\n", my_array[1]); // => 2 +// 在C99 （C11中是可选特性），变长数组（VLA）也可以声明长度。 +// 其长度不用是编译期常量。 +printf("Enter the array size: "); // 询问用户数组长度 +char buf[0x100]; +fgets(buf, sizeof buf, stdin); + +// stroul 将字符串解析为无符号整数 +size_t size = strtoul(buf, NULL, 10); +int var_length_array[size]; // 声明VLA +printf("sizeof array = %zu\n", sizeof var_length_array); + +// 上述程序可能的输出为： +// > Enter the array size: 10 +// > sizeof array = 40 + // 字符串就是以 NUL (0x00) 这个字符结尾的字符数组, -// 这个字符可以用'\0'来表示. -// (在字符串字面值中我们不必输入这个字符，编译器会自动添加的) +// NUL可以用'\0'来表示. +// (在字符串字面量中我们不必输入这个字符，编译器会自动添加的) char a_string[20] = "This is a string"; printf("%s\n", a_string); // %s 可以对字符串进行格式化 - /* 也许你会注意到 a_string 实际上只有16个字节长. 第17个字节是一个空字符(NUL) -而第18, 19 和 20 个字符的值是不确定的。 +而第18, 19 和 20 个字符的值是未定义。 */ printf("%d\n", a_string[16]); // => 0 +// byte #17值为0（18，19，20同样为0） + +// 单引号间的字符是字符字面量 +// 它的类型是`int`，而 *不是* `char` +// （由于历史原因） +int cha = 'a'; // 合法 +char chb = 'a'; // 同样合法 (隐式类型转换 + +// 多维数组 +int multi_array[2][5] = { + {1, 2, 3, 4, 5}, + {6, 7, 8, 9, 0} + } +// 获取元素 +int array_int = multi_array[0][2]; // => 3 /////////////////////////////////////// // 操作符 /////////////////////////////////////// -int i1 = 1, i2 = 2; // 多个变量声明的简写 +// 多个变量声明的简写 +int i1 = 1, i2 = 2; float f1 = 1.0, f2 = 2.0; -// 算数运算 +int a, b, c; +a = b = c = 0; + +// 算数运算直截了当 i1 + i2; // => 3 i2 - i1; // => 1 i2 * i1; // => 2 -i1 / i2; // => 0 (0.5 会被化整为 0) +i1 / i2; // => 0 (0.5，但会被化整为 0) f1 / f2; // => 0.5, 也许会有很小的误差 +// 浮点数和浮点数运算都是近似值 // 取余运算 11 % 3; // => 2 -// 比较操作符我们也很熟悉, 但是有一点，C中没有布尔类型 +// 你多半会觉得比较操作符很熟悉, 不过C中没有布尔类型 // 而是用整形替代 -// 0 就是 false, 其他的就是 true. (比较操作符的返回值则仅有0和1) +// (C99中有_Bool或bool。) +// 0为假, 其他均为真. (比较操作符的返回值总是返回0或1) 3 == 2; // => 0 (false) 3 != 2; // => 1 (true) 3 > 2; // => 1 @@ -137,7 +199,14 @@ f1 / f2; // => 0.5, 也许会有很小的误差 2 <= 2; // => 1 2 >= 2; // => 1 -// 逻辑运算符需要作用于整数 +// C不是Python —— 连续比较不合法 +int a = 1; +// 错误 +int between_0_and_2 = 0 < a < 2; +// 正确 +int between_0_and_2 = 0 < a && a < 2; + +// 逻辑运算符适用于整数 !3; // => 0 (非) !0; // => 1 1 && 1; // => 1 (且) @@ -145,6 +214,20 @@ f1 / f2; // => 0.5, 也许会有很小的误差 0 || 1; // => 1 (或) 0 || 0; // => 0 +// 条件表达式 （ ? : ） +int a = 5; +int b = 10; +int z; +z = (a > b) ? a : b; // 10 “若a > b返回a，否则返回b。” + +// 增、减 +char *s = "iLoveC" +int j = 0; +s[j++]; // "i" 返回s的第j项，然后增加j的值。 +j = 0; +s[++j]; // => "L" 增加j的值，然后返回s的第j项。 +// j-- 和 --j 同理 + // 位运算 ~0x0F; // => 0xF0 (取反) 0x0F & 0xF0; // => 0x00 (和) @@ -153,6 +236,13 @@ f1 / f2; // => 0.5, 也许会有很小的误差 0x01 << 1; // => 0x02 (左移1位) 0x02 >> 1; // => 0x01 (右移1位) +// 对有符号整数进行移位操作要小心 —— 以下未定义： +// 有符号整数位移至符号位 int a = 1 << 32 +// 左移位一个负数 int a = -1 << 2 +// 移位超过或等于该类型数值的长度 +// int a = 1 << 32; // 假定int32位 + + /////////////////////////////////////// // 控制结构 /////////////////////////////////////// @@ -167,17 +257,17 @@ if (0) { // While循环 int ii = 0; -while (ii < 10) { +while (ii < 10) { // 任何非0的值均为真 printf("%d, ", ii++); // ii++ 在取值过后自增 -} // => 输出 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " +} // => 打印 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); int kk = 0; do { printf("%d, ", kk); -} while (++kk < 10); // ++kk 先自增，在被取值 -// => 输出 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " +} while (++kk < 10); // ++kk 先自增，再被取值 +// => 打印 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); @@ -185,29 +275,55 @@ printf("\n"); int jj; for (jj=0; jj < 10; jj++) { printf("%d, ", jj); -} // => 输出 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " +} // => 打印 "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); +// *****注意*****: +// 循环和函数必须有主体部分，如果不需要主体部分： +int i; + for (i = 0; i <= 5; i++) { + ; // 使用分号表达主体（null语句） +} + +// 多重分支：switch() +switch (some_integral_expression) { +case 0: // 标签必须是整数常量表达式 + do_stuff(); + break; // 如果不使用break，控制结构会继续执行下面的标签 +case 1: + do_something_else(); + break; +default: + // 假设 `some_integral_expression` 不匹配任何标签 + fputs("error!\n", stderr); + exit(-1); + break; + } + /////////////////////////////////////// // 类型转换 /////////////////////////////////////// // 在C中每个变量都有类型，你可以将变量的类型进行转换 +// (有一定限制) -int x_hex = 0x01; // 可以用16进制赋值 +int x_hex = 0x01; // 可以用16进制字面量赋值 // 在类型转换时，数字本身的值会被保留下来 -printf("%d\n", x_hex); // => 输出 1 -printf("%d\n", (short) x_hex); // => 输出 1 -printf("%d\n", (char) x_hex); // => 输出 1 +printf("%d\n", x_hex); // => 打印 1 +printf("%d\n", (short) x_hex); // => 打印 1 +printf("%d\n", (char) x_hex); // => 打印 1 // 类型转换时可能会造成溢出，而且不会抛出警告 -printf("%d\n", (char) 257); // => 1 (char的最大值为255) +printf("%d\n", (char) 257); // => 1 (char的最大值为255，假定char为8位长) + +// 使用<limits.h>提供的CHAR_MAX、SCHAR_MAX和UCHAR_MAX宏可以确定`char`、`signed_char`和`unisigned char`的最大值。 + // 整数型和浮点型可以互相转换 -printf("%f\n", (float)100); // %f 表示单精度浮点 -printf("%lf\n", (double)100); // %lf 表示双精度浮点 +printf("%f\n", (float)100); // %f 格式化单精度浮点 +printf("%lf\n", (double)100); // %lf 格式化双精度浮点 printf("%d\n", (char)100.0); /////////////////////////////////////// @@ -215,67 +331,89 @@ printf("%d\n", (char)100.0); /////////////////////////////////////// // 指针变量是用来储存内存地址的变量 -// 指针变量的定义也会告诉你指向的地址的变量的类型 -// 你也可以得到某个变量的地址，并对它们进行操作 +// 指针变量的声明也会告诉它所指向的数据的类型 +// 你可以使用得到你的变量的地址，并把它们搞乱，;-) int x = 0; printf("%p\n", &x); // 用 & 来获取变量的地址 -// (%p 表示一个指针) -// => 输出某个内存地址 +// (%p 格式化一个类型为 void *的指针) +// => 打印某个内存地址 -// 指针类型在定义是需要以*结束 -int* px; // px是一个指向int型的指针 +// 指针类型在声明中以*开头 +int* px, not_a_pointer; // px是一个指向int型的指针 px = &x; // 把x的地址保存到px中 -printf("%p\n", px); // => 输出内存中的某个地址 +printf("%p\n", (void *)px); // => 输出内存中的某个地址 +printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer)); +// => 在64位系统上打印“8， 4”。 -// 要得到某个指针指向的内容的值，可以在指针前加一个*来取得（去引用） +// 要得到某个指针指向的内容的值，可以在指针前加一个*来取得（取消引用） +// 注意： 是的，这可能让人困惑，'*'在用来声明一个指针的同时取消引用它。 printf("%d\n", *px); // => 输出 0, 即x的值 // 你也可以改变指针所指向的值 -// 此时你需要在*运算符后添加一个括号，因为++比*的优先级更高 -(*px)++; // 把px所指向的值增加2 +// 此时你需要取消引用上添加括号，因为++比*的优先级更高 +(*px)++; // 把px所指向的值增加1 printf("%d\n", *px); // => 输出 1 printf("%d\n", x); // => 输出 1 -int x_array[20]; // 数组是分配一系列连续空间的常用方式 +// 数组是分配一系列连续空间的常用方式 +int x_array[20]; int xx; for (xx=0; xx<20; xx++) { x_array[xx] = 20 - xx; } // 初始化 x_array 为 20, 19, 18,... 2, 1 -// 生命一个变量为指向整型的指针类型，并初始化为指向x_array +// 声明一个整型的指针，并初始化为指向x_array int* x_ptr = x_array; // x_ptr现在指向了数组的第一个元素(即整数20). - -// 事实上数组本身就是指向它的第一个元素的指针 -printf("%d\n", *(x_ptr)); // => 输出 20 -printf("%d\n", x_array[0]); // => 输出 20 +// 这是因为数组通常衰减为指向它们的第一个元素的指针。 +// 例如，当一个数组被传递给一个函数或者绑定到一个指针时， +//它衰减为(隐式转化为）一个指针。 +// 例外： 当数组是`&`操作符的参数： +int arr[10]; +int (*ptr_to_arr)[10] = &arr; // &arr的类型不是`int *`！ + // 它的类型是指向数组的指针（数组由10个int组成） +// 或者当数组是字符串字面量（初始化字符数组） +char arr[] = "foobarbazquirk"; +// 或者当它是`sizeof`或`alignof`操作符的参数时： +int arr[10]; +int *ptr = arr; // 等价于 int *ptr = &arr[0]; +printf("%zu, %zu\n", sizeof arr, sizeof ptr); // 应该会输出"40, 4"或"40, 8" // 指针的增减多少是依据它本身的类型而定的 -printf("%d\n", *(x_ptr + 1)); // => 输出 19 -printf("%d\n", x_array[1]); // => 输出 19 +// （这被称为指针算术） +printf("%d\n", *(x_ptr + 1)); // => 打印 19 +printf("%d\n", x_array[1]); // => 打印 19 // 你也可以通过标准库函数malloc来实现动态分配 -// 这个函数接受一个代表容量的参数 -// 系统会从堆区分配指定容量字节大小的空间 -int* my_ptr = (int*) malloc(sizeof(int) * 20); +// 这个函数接受一个代表容量的参数，参数类型为`size_t` +// 系统一般会从堆区分配指定容量字节大小的空间 +// （在一些系统，例如嵌入式系统中这点不一定成立 +// C标准对此未置一词。） +int *my_ptr = malloc(sizeof(*my_ptr) * 20); for (xx=0; xx<20; xx++) { - *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 也可以 -} // 初始化内存为 20, 19, 18, 17... 2, 1 (as ints) + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx +} // 初始化内存为 20, 19, 18, 17... 2, 1 (类型为int） -// 如果对一些未分配的内存取值则会得到未知的结果 +// 对未分配的内存进行取消引用会产生未定义的结果 printf("%d\n", *(my_ptr + 21)); // => 谁知道会输出什么 -// 当你通过malloc得到一块区域后，你需要释放它 +// malloc分配的区域需要手动释放 // 否则没人能够再次使用这块内存，直到程序结束为止 free(my_ptr); // 字符串通常是字符数组，但是经常用字符指针表示 -// 指针: -char* my_str = "This is my very own string"; - +// (它是指向数组的第一个元素的指针) +// 一个优良的实践是使用`const char *`来引用一个字符串字面量， +// 因为字符串字面量不应当被修改（即"foo"[0] = 'a'犯了大忌） +const char* my_str = "This is my very own string"; printf("%c\n", *my_str); // => 'T' +// 如果字符串是数组，（多半是用字符串字面量初始化的） +// 情况就不一样了，字符串位于可写的内存中 +char foo[] = "foo"; +foo[0] = 'a'; // 这是合法的，foo现在包含"aoo" + function_1(); } // main函数结束 @@ -291,16 +429,21 @@ int add_two_ints(int x1, int x2){ } /* -函数是按值传递的, 但是你可以通过传递参数来传递引用，这样函数就可以更改值 +函数是按值传递的。当调用一个函数的时候，传递给函数的参数 +是原有值的拷贝（数组除外）。你在函数内对参数所进行的操作 +不会改变该参数原有的值。 + +但是你可以通过指针来传递引用，这样函数就可以更改值 例子：字符串本身翻转 */ // 类型为void的函数没有返回值 -void str_reverse(char* str_in){ +void str_reverse(char *str_in){ char tmp; - int ii=0, len = strlen(str_in); // Strlen 是C标准库函数 - for(ii=0; ii<len/2; ii++){ + int ii = 0; + size_t len = strlen(str_in); // `strlen()`` 是C标准库函数 + for(ii = 0; ii < len / 2; ii++){ tmp = str_in[ii]; str_in[ii] = str_in[len - ii - 1]; // 从倒数第ii个开始 str_in[len - ii - 1] = tmp; @@ -313,6 +456,20 @@ str_reverse(c); printf("%s\n", c); // => ".tset a si sihT" */ +// 如果引用函数之外的变量，必须使用extern关键字 +int i = 0; +void testFunc() { + extern int i; // 使用外部变量 i +} + +// 使用static确保external变量为源文件私有 +static int i = 0; // 其他使用 testFunc()的文件无法访问变量i +void testFunc() { + extern int i; +} +//**你同样可以声明函数为static** + + /////////////////////////////////////// // 用户自定义类型和结构 /////////////////////////////////////// @@ -321,12 +478,16 @@ printf("%s\n", c); // => ".tset a si sihT" typedef int my_type; my_type my_type_var = 0; -// 结构是一系列数据的集合 +// struct是数据的集合，成员依序分配，按照 +// 编写的顺序 struct rectangle { int width; int height; }; +// 一般而言，以下断言不成立： +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) +//这是因为structure成员之间可能存在潜在的间隙（为了对齐）[1] void function_1(){ @@ -337,12 +498,12 @@ void function_1(){ my_rec.height = 20; // 你也可以声明指向结构体的指针 - struct rectangle* my_rec_ptr = &my_rec; + struct rectangle *my_rec_ptr = &my_rec; - // 通过取值来改变结构体的成员... + // 通过取消引用来改变结构体的成员... (*my_rec_ptr).width = 30; - // ... 或者用 -> 操作符作为简写 + // ... 或者用 -> 操作符作为简写提高可读性 my_rec_ptr->height = 10; // Same as (*my_rec_ptr).height = 10; } @@ -353,18 +514,25 @@ int area(rect r){ return r.width * r.height; } +// 如果struct较大，你可以通过指针传递，避免 +// 复制整个struct。 +int area(const rect *r) +{ + return r->width * r->height; +} + /////////////////////////////////////// // 函数指针 /////////////////////////////////////// /* 在运行时，函数本身也被存放到某块内存区域当中 -函数指针就像其他指针一样, 但却可以被用来直接调用函数, -并且可以被四处传递（就像回调函数那样） -但是，定义的语法有可能在一开始会有些误解 +函数指针就像其他指针一样（不过是存储一个内存地址） 但却可以被用来直接调用函数, +并且可以四处传递回调函数 +但是，定义的语法初看令人有些迷惑 例子：通过指针调用str_reverse */ -void str_reverse_through_pointer(char * str_in) { +void str_reverse_through_pointer(char *str_in) { // 定义一个函数指针 f. void (*f)(char *); // 签名一定要与目标函数相同 f = &str_reverse; // 将函数的地址在运行时赋给指针 @@ -373,7 +541,7 @@ void str_reverse_through_pointer(char * str_in) { } /* -只要函数签名是正确的，任何时候都能将正确的函数赋给某个函数指针 +只要函数签名是正确的，任何时候都能将任何函数赋给某个函数指针 为了可读性和简洁性，函数指针经常和typedef搭配使用： */ @@ -383,12 +551,73 @@ typedef void (*my_fnp_type)(char *); // ... // my_fnp_type f; +// 特殊字符 +'\a' // bell +'\n' // 换行 +'\t' // tab +'\v' // vertical tab +'\f' // formfeed +'\r' // 回车 +'\b' // 退格 +'\0' // null，通常置于字符串的最后。 + // hello\n\0. 按照惯例，\0用于标记字符串的末尾。 +'\\' // 反斜杠 +'\?' // 问号 +'\'' // 单引号 +'\"' // 双引号 +'\xhh' // 十六进制数字. 例子: '\xb' = vertical tab +'\ooo' // 八进制数字. 例子: '\013' = vertical tab + +// 打印格式： +"%d" // 整数 +"%3d" // 3位以上整数 （右对齐文本） +"%s" // 字符串 +"%f" // float +"%ld" // long +"%3.2f" // 左3位以上、右2位以上十进制浮 +"%7.4s" // (字符串同样适用) +"%c" // 字母 +"%p" // 指针 +"%x" // 十六进制 +"%o" // 八进制 +"%%" // 打印 % + +/////////////////////////////////////// +// 演算优先级 +/////////////////////////////////////// +//---------------------------------------------------// +// 操作符 | 组合 // +//---------------------------------------------------// +// () [] -> . | 从左到右 // +// ! ~ ++ -- + = *(type)sizeof | 从右到左 // +// * / % | 从左到右 // +// + - | 从左到右 // +// << >> | 从左到右 // +// < <= > >= | 从左到右 // +// == != | 从左到右 // +// & | 从左到右 // +// ^ | 从左到右 // +// | | 从左到右 // +// && | 从左到右 // +// || | 从左到右 // +// ?: | 从右到左 // +// = += -= *= /= %= &= ^= |= <<= >>= | 从右到左 // +// , | 从左到右 // +//---------------------------------------------------// + ``` ## 更多阅读 -最好找一本 [K&R, aka "The C Programming Language", “C程序设计语言”](https://en.wikipedia.org/wiki/The_C_Programming_Language) +最好找一本 [K&R, aka "The C Programming Language", “C程序设计语言”](https://en.wikipedia.org/wiki/The_C_Programming_Language)。它是关于C最重要的一本书，由C的创作者撰写。不过需要留意的是它比较古老了，因此有些不准确的地方。 + -其他一些比较好的资源 [Learn C the hard way](http://c.learncodethehardway.org/book/) +另一个比较好的资源是 [Learn C the hard way](http://c.learncodethehardway.org/book/) +如果你有问题，请阅读[compl.lang.c Frequently Asked Questions](http://c-faq.com/)。 + +使用合适的空格、缩进，保持一致的代码风格非常重要。可读性强的代码比聪明的代码、高速的代码更重要。可以参考下[Linux内核编码风格](https://www.kernel.org/doc/Documentation/CodingStyle) +。 除了这些，多多Google吧 + +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member diff --git a/zh-cn/clojure-cn.html.markdown b/zh-cn/clojure-cn.html.markdown new file mode 100644 index 00000000..fa241384 --- /dev/null +++ b/zh-cn/clojure-cn.html.markdown @@ -0,0 +1,368 @@ +--- +language: clojure +filename: learnclojure-cn.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Bill Zhang", "http://jingege.github.io/"] +lang: zh-cn +--- + +Clojure是运行在JVM上的Lisp家族中的一员。她比Common Lisp更强调纯[函数式编程](https://en.wikipedia.org/wiki/Functional_programming)，且自发布时便包含了一组工具来处理状态。 + +这种组合让她能十分简单且自动地处理并发问题。 + +(你需要使用Clojure 1.2或更新的发行版) + +```clojure +; 注释以分号开始。 + +; Clojure代码由一个个form组成， 即写在小括号里的由空格分开的一组语句。 +; Clojure解释器会把第一个元素当做一个函数或者宏来调用，其余的被认为是参数。 + +; Clojure代码的第一条语句一般是用ns来指定当前的命名空间。 +(ns learnclojure) + +; 更基本的例子: + +; str会使用所有参数来创建一个字符串 +(str "Hello" " " "World") ; => "Hello World" + +; 数学计算比较直观 +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 + +; 等号是 = +(= 1 1) ; => true +(= 2 1) ; => false + +; 逻辑非 +(not true) ; => false + +; 嵌套的form工作起来应该和你预想的一样 +(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2 + +; 类型 +;;;;;;;;;;;;; + +; Clojure使用Java的Object来描述布尔值、字符串和数字 +; 用函数 `class` 来查看具体的类型 +(class 1) ; 整形默认是java.lang.Long类型 +(class 1.); 浮点默认是java.lang.Double类型的 +(class ""); String是java.lang.String类型的，要用双引号引起来 +(class false) ; 布尔值是java.lang.Boolean类型的 +(class nil); "null"被称作nil + +; 如果你想创建一组数据字面量，用单引号(')来阻止form被解析和求值 +'(+ 1 2) ; => (+ 1 2) +; (单引号是quote的简写形式，故上式等价于(quote (+ 1 2))) + +; 可以对一个引用列表求值 +(eval '(+ 1 2)) ; => 3 + +; 集合（Collection）和序列 +;;;;;;;;;;;;;;;;;;; + +; List的底层实现是链表，Vector的底层实现是数组 +; 二者也都是java类 +(class [1 2 3]); => clojure.lang.PersistentVector +(class '(1 2 3)); => clojure.lang.PersistentList + +; list本可以写成(1 2 3), 但必须用引用来避免被解释器当做函数来求值。 +; (list 1 2 3)等价于'(1 2 3) + +; 集合其实就是一组数据 +; List和Vector都是集合: +(coll? '(1 2 3)) ; => true +(coll? [1 2 3]) ; => true + +; 序列 (seqs) 是数据列表的抽象描述 +; 只有列表才可称作序列。 +(seq? '(1 2 3)) ; => true +(seq? [1 2 3]) ; => false + +; 序列被访问时只需要提供一个值，所以序列可以被懒加载——也就意味着可以定义一个无限序列： +(range 4) ; => (0 1 2 3) +(range) ; => (0 1 2 3 4 ...) (无限序列) +(take 4 (range)) ; (0 1 2 3) + +; cons用以向列表或向量的起始位置添加元素 +(cons 4 [1 2 3]) ; => (4 1 2 3) +(cons 4 '(1 2 3)) ; => (4 1 2 3) + +; conj将以最高效的方式向集合中添加元素。 +; 对于列表，数据会在起始位置插入，而对于向量，则在末尾位置插入。 +(conj [1 2 3] 4) ; => [1 2 3 4] +(conj '(1 2 3) 4) ; => (4 1 2 3) + +; 用concat来合并列表或向量 +(concat [1 2] '(3 4)) ; => (1 2 3 4) + +; 用filter来过滤集合中的元素，用map来根据指定的函数来映射得到一个新的集合 +(map inc [1 2 3]) ; => (2 3 4) +(filter even? [1 2 3]) ; => (2) + +; recuce使用函数来规约集合 +(reduce + [1 2 3 4]) +; = (+ (+ (+ 1 2) 3) 4) +; => 10 + +; reduce还能指定一个初始参数 +(reduce conj [] '(3 2 1)) +; = (conj (conj (conj [] 3) 2) 1) +; => [3 2 1] + +; 函数 +;;;;;;;;;;;;;;;;;;;;; + +; 用fn来创建函数。函数的返回值是最后一个表达式的值 +(fn [] "Hello World") ; => fn + +; (你需要再嵌套一组小括号来调用它) +((fn [] "Hello World")) ; => "Hello World" + +; 你可以用def来创建一个变量（var） +(def x 1) +x ; => 1 + +; 将函数定义为一个变量（var） +(def hello-world (fn [] "Hello World")) +(hello-world) ; => "Hello World" + +; 你可用defn来简化函数的定义 +(defn hello-world [] "Hello World") + +; 中括号内的内容是函数的参数。 +(defn hello [name] + (str "Hello " name)) +(hello "Steve") ; => "Hello Steve" + +; 你还可以用这种简写的方式来创建函数： +(def hello2 #(str "Hello " %1)) +(hello2 "Fanny") ; => "Hello Fanny" + +; 函数也可以有多个参数列表。 +(defn hello3 + ([] "Hello World") + ([name] (str "Hello " name))) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" + +; 可以定义变参函数，即把&后面的参数全部放入一个序列 +(defn count-args [& args] + (str "You passed " (count args) " args: " args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" + +; 可以混用定参和变参（用&来界定） +(defn hello-count [name & args] + (str "Hello " name ", you passed " (count args) " extra args")) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" + + +; 哈希表 +;;;;;;;;;; + +; 基于hash的map和基于数组的map（即arraymap）实现了相同的接口，hashmap查询起来比较快， +; 但不保证元素的顺序。 +(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap +(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap + +; arraymap在足够大的时候，大多数操作会将其自动转换成hashmap， +; 所以不用担心(对大的arraymap的查询性能)。 + +; map支持很多类型的key，但推荐使用keyword类型 +; keyword类型和字符串类似，但做了一些优化。 +(class :a) ; => clojure.lang.Keyword + +(def stringmap {"a" 1, "b" 2, "c" 3}) +stringmap ; => {"a" 1, "b" 2, "c" 3} + +(def keymap {:a 1, :b 2, :c 3}) +keymap ; => {:a 1, :c 3, :b 2} + +; 顺便说一下，map里的逗号是可有可无的，作用只是提高map的可读性。 + +; 从map中查找元素就像把map名作为函数调用一样。 +(stringmap "a") ; => 1 +(keymap :a) ; => 1 + +; 可以把keyword写在前面来从map中查找元素。 +(:b keymap) ; => 2 + +; 但不要试图用字符串类型的key来这么做。 +;("a" stringmap) +; => Exception: java.lang.String cannot be cast to clojure.lang.IFn + +; 查找不存在的key会返回nil。 +(stringmap "d") ; => nil + +; 用assoc函数来向hashmap里添加元素 +(def newkeymap (assoc keymap :d 4)) +newkeymap ; => {:a 1, :b 2, :c 3, :d 4} + +; 但是要记住的是clojure的数据类型是不可变的！ +keymap ; => {:a 1, :b 2, :c 3} + +; 用dissoc来移除元素 +(dissoc keymap :a :b) ; => {:c 3} + +; 集合（Set） +;;;;;; + +(class #{1 2 3}) ; => clojure.lang.PersistentHashSet +(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3} + +; 用conj新增元素 +(conj #{1 2 3} 4) ; => #{1 2 3 4} + +; 用disj移除元素 +(disj #{1 2 3} 1) ; => #{2 3} + +; 把集合当做函数调用来检查元素是否存在: +(#{1 2 3} 1) ; => 1 +(#{1 2 3} 4) ; => nil + +; 在clojure.sets模块下有很多相关函数。 + +; 常用的form +;;;;;;;;;;;;;;;;; + +; clojure里的逻辑控制结构都是用宏（macro）实现的，这在语法上看起来没什么不同。 +(if false "a" "b") ; => "b" +(if false "a") ; => nil + +; 用let来创建临时的绑定变量。 +(let [a 1 b 2] + (> a b)) ; => false + +; 用do将多个语句组合在一起依次执行 +(do + (print "Hello") + "World") ; => "World" (prints "Hello") + +; 函数定义里有一个隐式的do +(defn print-and-say-hello [name] + (print "Saying hello to " name) + (str "Hello " name)) +(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff") + +; let也是如此 +(let [name "Urkel"] + (print "Saying hello to " name) + (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") + +; 模块 +;;;;;;;;;;;;;;; + +; 用use来导入模块里的所有函数 +(use 'clojure.set) + +; 然后就可以使用set相关的函数了 +(intersection #{1 2 3} #{2 3 4}) ; => #{2 3} +(difference #{1 2 3} #{2 3 4}) ; => #{1} + +; 你也可以从一个模块里导入一部分函数。 +(use '[clojure.set :only [intersection]]) + +; 用require来导入一个模块 +(require 'clojure.string) + +; 用/来调用模块里的函数 +; 下面是从模块`clojure.string`里调用`blank?`函数。 +(clojure.string/blank? "") ; => true + +; 在`import`里你可以给模块名指定一个较短的别名。 +(require '[clojure.string :as str]) +(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst." +; (#""用来表示一个正则表达式) + +; 你可以在一个namespace定义里用:require的方式来require（或use，但最好不要用）模块。 +; 这样的话你无需引用模块列表。 +(ns test + (:require + [clojure.string :as str] + [clojure.set :as set])) + +; Java +;;;;;;;;;;;;;;;;; + +; Java有大量的优秀的库，你肯定想学会如何用clojure来使用这些Java库。 + +; 用import来导入java类 +(import java.util.Date) + +; 也可以在ns定义里导入 +(ns test + (:import java.util.Date + java.util.Calendar)) + +; 用类名末尾加`.`的方式来new一个Java对象 +(Date.) ; <a date object> + +; 用`.`操作符来调用方法，或者用`.method`的简化方式。 +(. (Date.) getTime) ; <a timestamp> +(.getTime (Date.)) ; 和上例一样。 + +; 用`/`调用静态方法 +(System/currentTimeMillis) ; <a timestamp> (system is always present) + +; 用`doto`来更方便的使用（可变）类。 +(import java.util.Calendar) +(doto (Calendar/getInstance) + (.set 2000 1 1 0 0 0) + .getTime) ; => A Date. set to 2000-01-01 00:00:00 + +; STM +;;;;;;;;;;;;;;;;; + +; 软件内存事务（Software Transactional Memory）被clojure用来处理持久化的状态。 +; clojure里内置了一些结构来使用STM。 +; atom是最简单的。给它传一个初始值 +(def my-atom (atom {})) + +; 用`swap!`更新atom。 +; `swap!`会以atom的当前值为第一个参数来调用一个指定的函数， +; `swap`其余的参数作为该函数的第二个参数。 +(swap! my-atom assoc :a 1) ; Sets my-atom to the result of (assoc {} :a 1) +(swap! my-atom assoc :b 2) ; Sets my-atom to the result of (assoc {:a 1} :b 2) + +; 用`@`读取atom的值 +my-atom ;=> Atom<#...> (返回Atom对象) +@my-atom ; => {:a 1 :b 2} + +; 下例是一个使用atom实现的简单计数器 +(def counter (atom 0)) +(defn inc-counter [] + (swap! counter inc)) + +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) +(inc-counter) + +@counter ; => 5 + +; 其他STM相关的结构是ref和agent. +; Refs: http://clojure.org/refs +; Agents: http://clojure.org/agents +``` + +### 进阶读物 + +本文肯定不足以讲述关于clojure的一切，但是希望足以让你迈出第一步。 + +Clojure.org官网有很多文章: +[http://clojure.org/](http://clojure.org/) + +Clojuredocs.org有大多数核心函数的文档，还带了示例哦: +[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) + +4Clojure是个很赞的用来练习clojure/FP技能的地方: +[http://www.4clojure.com/](http://www.4clojure.com/) + +Clojure-doc.org (你没看错)有很多入门级的文章: +[http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/zh-cn/clojure-macro-cn.html.markdown b/zh-cn/clojure-macro-cn.html.markdown new file mode 100644 index 00000000..9324841e --- /dev/null +++ b/zh-cn/clojure-macro-cn.html.markdown @@ -0,0 +1,152 @@ +--- +language: "clojure macros" +filename: learnclojuremacros-zh.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Jakukyo Friel", "http://weakish.github.io"] +lang: zh-cn +--- + +和所有Lisp一样，Clojure内在的[同构性](https://en.wikipedia.org/wiki/Homoiconic)使得你可以穷尽语言的特性，编写生成代码的子过程——“宏”。宏是一种按需调制语言的强大方式。 + +小心！可以用函数完成的事用宏去实现可不是什么好事。你应该仅在需要控制参数是否或者何时eval的时候使用宏。 + +你应该熟悉Clojure.确保你了解[Y分钟学Clojure](http://learnxinyminutes.com/docs/zh-cn/clojure-cn/)中的所有内容。 + +```clojure +;; 使用defmacro定义宏。宏应该输出一个可以作为clojure代码演算的列表。 +;; +;; 以下宏的效果和直接写(reverse "Hello World")一致。 + +(defmacro my-first-macro [] + (list reverse "Hello World")) + +;; 使用macroexpand或macroexpand-1查看宏的结果。 +;; +;; 注意，调用需要引用。 +(macroexpand '(my-first-macro)) +;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World") + +;; 你可以直接eval macroexpand的结果 +(eval (macroexpand '(my-first-macro))) +; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; 不过一般使用以下形式，更简短，更像函数： +(my-first-macro) ; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; 创建宏的时候可以使用更简短的引用形式来创建列表 +(defmacro my-first-quoted-macro [] + '(reverse "Hello World")) + +(macroexpand '(my-first-quoted-macro)) +;; -> (reverse "Hello World") +;; 注意reverse不再是一个函数对象，而是一个符号。 + +;; 宏可以传入参数。 +(defmacro inc2 [arg] + (list + 2 arg)) + +(inc2 2) ; -> 4 + +;; 不过，如果你尝试配合使用引用列表，会导致错误， +;; 因为参数也会被引用。 +;; 为了避免这个问题，clojure提供了引用宏的另一种方式：` +;; 在`之内，你可以使用~获得外圈作用域的变量。 +(defmacro inc2-quoted [arg] + `(+ 2 ~arg)) + +(inc2-quoted 2) + +;; 你可以使用通常的析构参数。用~@展开列表中的变量。 +(defmacro unless [arg & body] + `(if (not ~arg) + (do ~@body))) ; 别忘了 do! + +(macroexpand '(unless true (reverse "Hello World"))) + +;; -> +;; (if (clojure.core/not true) (do (reverse "Hello World"))) + +;; 当第一个参数为假时，(unless)会演算、返回主体。 +;; 否则返回nil。 + +(unless true "Hello") ; -> nil +(unless false "Hello") ; -> "Hello" + +;; 需要小心，宏会搞乱你的变量 +(defmacro define-x [] + '(do + (def x 2) + (list x))) + +(def x 4) +(define-x) ; -> (2) +(list x) ; -> (2) + +;; 使用gensym来获得独有的标识符 +(gensym 'x) ; -> x1281 (or some such thing) + +(defmacro define-x-safely [] + (let [sym (gensym 'x)] + `(do + (def ~sym 2) + (list ~sym)))) + +(def x 4) +(define-x-safely) ; -> (2) +(list x) ; -> (4) + +;; 你可以在 ` 中使用 # 为每个符号自动生成gensym +(defmacro define-x-hygenically [] + `(do + (def x# 2) + (list x#))) + +(def x 4) +(define-x-hygenically) ; -> (2) +(list x) ; -> (4) + +;; 通常会配合宏使用帮助函数。 +;; 让我们创建一些帮助函数来支持（无聊的）算术语法： + +(declare inline-2-helper) +(defn clean-arg [arg] + (if (seq? arg) + (inline-2-helper arg) + arg)) + +(defn apply-arg + "Given args [x (+ y)], return (+ x y)" + [val [op arg]] + (list op val (clean-arg arg))) + +(defn inline-2-helper + [[arg1 & ops-and-args]] + (let [ops (partition 2 ops-and-args)] + (reduce apply-arg (clean-arg arg1) ops))) + +;; 在创建宏前，我们可以先测试 +(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5)) + +; 然而，如果我们希望它在编译期执行，就需要创建宏 +(defmacro inline-2 [form] + (inline-2-helper form))) + +(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1))) +; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1) + +(inline-2 (1 + (3 / 2) - (1 / 2) + 1)) +; -> 3 (事实上，结果是3N, 因为数字被转化为带/的有理分数） +``` + +## 扩展阅读 + +[Clojure for the Brave and True](http://www.braveclojure.com/)系列的编写宏 +http://www.braveclojure.com/writing-macros/ + +官方文档 +http://clojure.org/macros + +何时使用宏？ +http://dunsmor.com/lisp/onlisp/onlisp_12.html diff --git a/zh-cn/coffeescript-cn.html.markdown b/zh-cn/coffeescript-cn.html.markdown new file mode 100644 index 00000000..44561541 --- /dev/null +++ b/zh-cn/coffeescript-cn.html.markdown @@ -0,0 +1,101 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Xavier Yao", "http://github.com/xavieryao"] +filename: coffeescript-cn.coffee +lang: zh-cn +--- + +CoffeeScript是逐句编译为JavaScript的一种小型语言，且没有运行时的解释器。 +作为JavaScript的替代品之一，CoffeeScript旨在编译人类可读、美观优雅且速度不输原生的代码， +且编译后的代码可以在任何JavaScript运行时正确运行。 + +参阅 [CoffeeScript官方网站](http://coffeescript.org/)以获取CoffeeScript的完整教程。 + +``` coffeescript +# CoffeeScript是一种很潮的编程语言， +# 它紧随众多现代编程语言的趋势。 +# 因此正如Ruby和Python，CoffeeScript使用井号标记注释。 + +### +大段落注释以此为例，可以被直接编译为 '/ *' 和 '* /' 包裹的JavaScript代码。 + +在继续之前你需要了解JavaScript的基本概念。 + +示例中 => 后为编译后的JavaScript代码 +### + +# 赋值: +number = 42 #=> var number = 42; +opposite = true #=> var opposite = true; + +# 条件: +number = -42 if opposite #=> if(opposite) { number = -42; } + +# 函数: +square = (x) -> x * x #=> var square = function(x) { return x * x; } + +fill = (container, liquid = "coffee") -> + "Filling the #{container} with #{liquid}..." +#=>var fill; +# +#fill = function(container, liquid) { +# if (liquid == null) { +# liquid = "coffee"; +# } +# return "Filling the " + container + " with " + liquid + "..."; +#}; + +# 区间: +list = [1..5] #=> var list = [1, 2, 3, 4, 5]; + +# 对象: +math = + root: Math.sqrt + square: square + cube: (x) -> x * square x +#=> var math = { +# "root": Math.sqrt, +# "square": square, +# "cube": function(x) { return x * square(x); } +#} + +# Splats: +race = (winner, runners...) -> + print winner, runners +#=>race = function() { +# var runners, winner; +# winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(winner, runners); +#}; + +# 存在判断: +alert "I knew it!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); } + +# 数组推导: +cubes = (math.cube num for num in list) +#=>cubes = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +foods = ['broccoli', 'spinach', 'chocolate'] +eat food for food in foods when food isnt 'chocolate' +#=>foods = ['broccoli', 'spinach', 'chocolate']; +# +#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) { +# food = foods[_k]; +# if (food !== 'chocolate') { +# eat(food); +# } +#} +``` diff --git a/zh-cn/common-lisp-cn.html.markdown b/zh-cn/common-lisp-cn.html.markdown new file mode 100644 index 00000000..b82829a9 --- /dev/null +++ b/zh-cn/common-lisp-cn.html.markdown @@ -0,0 +1,624 @@ +--- +language: "Common Lisp" +filename: commonlisp-cn.lisp +contributors: + - ["Paul Nathan", "https://github.com/pnathan"] +translators: + - ["Mac David", "http://macdavid313.com"] + - ["mut0u", "http://github.com/mut0u"] +lang: zh-cn +--- + +ANSI Common Lisp 是一个广泛通用于各个工业领域的、支持多种范式的编程语言。 +这门语言也经常被引用作“可编程的编程语言”（可以写代码的代码）。 + +免费的经典的入门书籍[《实用 Common Lisp 编程》](http://www.gigamonkeys.com/book/) + +另外还有一本热门的近期出版的 +[Land of Lisp](http://landoflisp.com/). + +```common-lisp +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 0. 语法 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 一般形式 + +;; Lisp有两个基本的语法单元：原子（atom），以及S-表达式。 +;; 一般的，一组S-表达式被称为“组合式”。 + +10 ; 一个原子; 它对自身进行求值 + +:THING ;同样是一个原子；它被求值为一个符号 :thing + +t ;还是一个原子，代表逻辑真值。 + +(+ 1 2 3 4) ; 一个S-表达式。 + +'(4 :foo t) ;同样是一个S-表达式。 + + +;;; 注释 + +;; 一个分号开头的注释表示仅用于此行（单行）；两个分号开头的则表示一个所谓标准注释； +;; 三个分号开头的意味着段落注释； +;; 而四个分号开头的注释用于文件头注释（译者注：即对该文件的说明）。 + +#| 块注释 + 可以涵盖多行，而且... + #| + 他们可以被嵌套！ + |# +|# + +;;; 运行环境 + +;; 有很多不同的Common Lisp的实现；并且大部分的实现是一致（可移植）的。 +;; 对于入门学习来说，CLISP是个不错的选择。 + +;; 可以通过QuickLisp.org的Quicklisp系统管理你的库。 + +;; 通常，使用文本编辑器和“REPL”来开发Common Lisp； +;; （译者注：“REPL”指读取-求值-打印循环）。 +;; “REPL”允许对程序进行交互式的运行、调试，就好像在系统“现场”操作。 + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 1. 基本数据类型以及运算符 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 符号 + +'foo ; => FOO 注意到这个符号被自动转换成大写了。 + +;; `intern`由一个给定的字符串而创建相应的符号 + +(intern "AAAA") ; => AAAA + +(intern "aaa") ; => |aaa| + +;;; 数字 +9999999999999999999999 ; 整型数 +#b111 ; 二进制 => 7 +#o111 ; 八进制 => 73 +#x111 ; 十六进制 => 273 +3.14159s0 ; 单精度 +3.14159d0 ; 双精度 +1/2 ; 分数 +#C(1 2) ; 复数 + + +;; 使用函数时，应当写成这样的形式：(f x y z ...)； +;; 其中，f是一个函数（名），x, y, z为参数； +;; 如果你想创建一个“字面”意义上（即不求值）的列表， 只需使用单引号 ' ， +;; 从而避免接下来的表达式被求值。即，只“引用”这个数据（而不求值）。 +'(+ 1 2) ; => (+ 1 2) +;; 你同样也可以手动地调用一个函数（译者注：即使用函数对象来调用函数）： +(funcall #'+ 1 2 3) ; => 6 +;; 一些算术运算符 +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(mod 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(+ #C(1 2) #C(6 -4)) ; => #C(7 -2) + + ;;; 布尔运算 +t ; 逻辑真（任何不是nil的值都被视为真值） +nil ; 逻辑假，或者空列表 +(not nil) ; => t +(and 0 t) ; => t +(or 0 nil) ; => 0 + + ;;; 字符 +#\A ; => #\A +#\λ ; => #\GREEK_SMALL_LETTER_LAMDA（希腊字母Lambda的小写） +#\u03BB ; => #\GREEK_SMALL_LETTER_LAMDA（Unicode形式的小写希腊字母Lambda） + +;;; 字符串被视为一个定长字符数组 +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ;反斜杠用作转义字符 + +;; 可以拼接字符串 +(concatenate 'string "Hello " "world!") ; => "Hello world!" + +;; 一个字符串也可被视作一个字符序列 +(elt "Apple" 0) ; => #\A + +;; `format`被用于格式化字符串 +(format nil "~a can be ~a" "strings" "formatted") + +;; 利用`format`打印到屏幕上是非常简单的 +;;（译者注：注意到第二个参数是t，不同于刚刚的nil）；~% 代表换行符 +(format t "Common Lisp is groovy. Dude.~%") + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. 变量 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 你可以通过`defparameter`创建一个全局（动态）变量 +;; 变量名可以是除了：()[]{}",'`;#|\ 这些字符之外的其他任何字符 + +;; 动态变量名应该由*号开头与结尾！ +;; (译者注：这个只是一个习惯) + +(defparameter *some-var* 5) +*some-var* ; => 5 + +;; 你也可以使用Unicode字符： +(defparameter *AΛB* nil) + + +;; 访问一个在之前从未被绑定的变量是一种不规范的行为（即使依然是可能发生的）； +;; 不要尝试那样做。 + + +;; 局部绑定：在(let ...)语句内，'me'被绑定到"dance with you"上。 +;; `let`总是返回在其作用域内最后一个表达式的值 + +(let ((me "dance with you")) + me) +;; => "dance with you" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 结构体和集合 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 结构体 +(defstruct dog name breed age) +(defparameter *rover* + (make-dog :name "rover" + :breed "collie" + :age 5)) +*rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5) + +(dog-p *rover*) ; => t ;; ewww) +(dog-name *rover*) ; => "rover" + +;; Dog-p，make-dog，以及 dog-name都是由defstruct创建的！ + +;;; 点对单元(Pairs) +;; `cons`可用于生成一个点对单元， 利用`car`以及`cdr`将分别得到第一个和第二个元素 +(cons 'SUBJECT 'VERB) ; => '(SUBJECT . VERB) +(car (cons 'SUBJECT 'VERB)) ; => SUBJECT +(cdr (cons 'SUBJECT 'VERB)) ; => VERB + +;;; 列表 + +;; 所有列表都是由点对单元构成的“链表”。它以'nil'（或者'()）作为列表的最后一个元素。 +(cons 1 (cons 2 (cons 3 nil))) ; => '(1 2 3) +;; `list`是一个生成列表的便利途径 +(list 1 2 3) ; => '(1 2 3) +;; 并且，一个引用也可被用做字面意义上的列表值 +'(1 2 3) ; => '(1 2 3) + +;; 同样的，依然可以用`cons`来添加一项到列表的起始位置 +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; 而`append`也可用于连接两个列表 +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; 或者使用`concatenate` + +(concatenate 'list '(1 2) '(3 4)) + +;; 列表是一种非常核心的数据类型，所以有非常多的处理列表的函数 +;; 例如： +(mapcar #'1+ '(1 2 3)) ; => '(2 3 4) +(mapcar #'+ '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4) +(every #'evenp '(1 2 3 4)) ; => nil +(some #'oddp '(1 2 3 4)) ; => T +(butlast '(subject verb object)) ; => (SUBJECT VERB) + + +;;; 向量 + +;; 向量的字面意义是一个定长数组 +;;（译者注：此处所谓“字面意义”，即指#(......)的形式，下文还会出现） +#(1 2 3) ; => #(1 2 3) + +;; 使用`concatenate`来将两个向量首尾连接在一起 +(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; 数组 + +;; 向量和字符串只不过是数组的特例 + +;; 二维数组 + +(make-array (list 2 2)) + +;; (make-array '(2 2)) 也是可以的 + +; => #2A((0 0) (0 0)) + +(make-array (list 2 2 2)) + +; => #3A(((0 0) (0 0)) ((0 0) (0 0))) + +;; 注意：数组的默认初始值是可以指定的 +;; 下面是如何指定的示例： + +(make-array '(2) :initial-element 'unset) + +; => #(UNSET UNSET) + +;; 若想获取数组[1][1][1]上的元素： +(aref (make-array (list 2 2 2)) 1 1 1) + +; => 0 + +;;; 变长向量 + +;; 若将变长向量打印出来，那么它的字面意义上的值和定长向量的是一样的 + +(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3) + :adjustable t :fill-pointer t)) + +*adjvec* ; => #(1 2 3) + +;; 添加新的元素: +(vector-push-extend 4 *adjvec*) ; => 3 + +*adjvec* ; => #(1 2 3 4) + + + +;;; 不怎么严谨地说，集合也可被视为列表 + +(set-difference '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1) +(intersection '(1 2 3 4) '(4 5 6 7)) ; => 4 +(union '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1 4 5 6 7) +(adjoin 4 '(1 2 3 4)) ; => (1 2 3 4) + +;; 然而，你可能想使用一个更好的数据结构，而并非一个链表 + +;;; 在Common Lisp中，“字典”和哈希表的实现是一样的。 + +;; 创建一个哈希表 +(defparameter *m* (make-hash-table)) + +;; 给定键，设置对应的值 +(setf (gethash 'a *m*) 1) + +;; （通过键）检索对应的值 +(gethash 'a *m*) ; => 1, t + +;; 注意此处有一细节：Common Lisp往往返回多个值。`gethash`返回的两个值是t，代表找到了这个元素；返回nil表示没有找到这个元素。 +;;（译者注：返回的第一个值表示给定的键所对应的值或者nil；） +;;（第二个是一个布尔值，表示在哈希表中是否存在这个给定的键） +;; 例如，如果可以找到给定的键所对应的值，则返回一个t，否则返回nil + +;; 由给定的键检索一个不存在的值，则返回nil +;;（译者注：这个nil是第一个nil，第二个nil其实是指该键在哈希表中也不存在） + (gethash 'd *m*) ;=> nil, nil + +;; 给定一个键，你可以指定其对应的默认值： +(gethash 'd *m* :not-found) ; => :NOT-FOUND + +;; 在此，让我们看一看怎样处理`gethash`的多个返回值。 + +(multiple-value-bind + (a b) + (gethash 'd *m*) + (list a b)) +; => (NIL NIL) + +(multiple-value-bind + (a b) + (gethash 'a *m*) + (list a b)) +; => (1 T) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 函数 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 使用`lambda`来创建一个匿名函数。 +;; 一个函数总是返回其形式体内最后一个表达式的值。 +;; 将一个函数对象打印出来后的形式是多种多样的... + +(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}> + +;; 使用`funcall`来调用lambda函数 +(funcall (lambda () "Hello World")) ; => "Hello World" + +;; 或者使用`apply` +(apply (lambda () "Hello World") nil) ; => "Hello World" + +;; 显式地定义一个函数（译者注：即非匿名的） +(defun hello-world () + "Hello World") +(hello-world) ; => "Hello World" + +;; 刚刚上面函数名"hello-world"后的()其实是函数的参数列表 +(defun hello (name) + (format nil "Hello, ~a " name)) + +(hello "Steve") ; => "Hello, Steve" + +;; 函数可以有可选形参并且其默认值都为nil + +(defun hello (name &optional from) + (if from + (format t "Hello, ~a, from ~a" name from) + (format t "Hello, ~a" name))) + + (hello "Jim" "Alpacas") ;; => Hello, Jim, from Alpacas + +;; 你也可以指定那些可选形参的默认值 +(defun hello (name &optional (from "The world")) + (format t "Hello, ~a, from ~a" name from)) + +(hello "Steve") +; => Hello, Steve, from The world + +(hello "Steve" "the alpacas") +; => Hello, Steve, from the alpacas + + +;; 当然，你也可以设置所谓关键字形参； +;; 关键字形参往往比可选形参更具灵活性。 + +(defun generalized-greeter (name &key (from "the world") (honorific "Mx")) + (format t "Hello, ~a ~a, from ~a" honorific name from)) + +(generalized-greeter "Jim") ; => Hello, Mx Jim, from the world + +(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr") +; => Hello, Mr Jim, from the alpacas you met last summer + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. 等式 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Common Lisp具有一个十分复杂的用于判断等价的系统，下面只是其中一部分的例子 + +;; 若要比较数值是否等价，使用`=` +(= 3 3.0) ; => t +(= 2 1) ; => nil + +;; 若要比较对象的类型，则使用`eql` +;;（译者注：抱歉，翻译水平实在有限，下面是我个人的补充说明） +;;（`eq` 返回真，如果对象的内存地址相等） +;;（`eql` 返回真，如果两个对象内存地址相等，或者对象的类型相同，并且值相等） +;;（例如同为整形数或浮点数，并且他们的值相等时，二者`eql`等价） +;;（想要弄清`eql`，其实有必要先了解`eq`) +;;（[可以参考](http://stackoverflow.com/questions/547436/whats-the-difference-between-eq-eql-equal-and-equalp-in-common-lisp)） +;;（可以去CLHS上分别查看两者的文档） +;;（另外，《实用Common Lisp编程》的4.8节也提到了两者的区别） +(eql 3 3) ; => t +(eql 3 3.0) ; => nil +(eql (list 3) (list 3)) ; => nil + +;; 对于列表、字符串、以及位向量，使用`equal` +(equal (list 'a 'b) (list 'a 'b)) ; => t +(equal (list 'a 'b) (list 'b 'a)) ; => nil + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. 控制流 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 条件判断语句 + +(if t ; “test”，即判断语句 + "this is true" ; “then”，即判断条件为真时求值的表达式 + "this is false") ; “else”，即判断条件为假时求值的表达式 +; => "this is true" + +;; 在“test”（判断）语句中，所有非nil或者非()的值都被视为真值 +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'YEP + +;; `cond`将一系列测试语句串联起来，并对相应的表达式求值 +(cond ((> 2 2) (error "wrong!")) + ((< 2 2) (error "wrong again!")) + (t 'ok)) ; => 'OK + +;; 对于给定值的数据类型，`typecase`会做出相应地判断 +(typecase 1 + (string :string) + (integer :int)) + +; => :int + +;;; 迭代 + +;; 当然，递归是肯定被支持的： + +(defun walker (n) + (if (zerop n) + :walked + (walker (1- n)))) + +(walker) ; => :walked + +;; 而大部分场合下，我们使用`DOLIST`或者`LOOP`来进行迭代 + + +(dolist (i '(1 2 3 4)) + (format t "~a" i)) + +; => 1234 + +(loop for i from 0 below 10 + collect i) + +; => (0 1 2 3 4 5 6 7 8 9) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. 可变性 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 使用`setf`可以对一个已经存在的变量进行赋值； +;; 事实上，刚刚在哈希表的例子中我们已经示范过了。 + +(let ((variable 10)) + (setf variable 2)) + ; => 2 + + +;; 所谓好的Lisp编码风格就是为了减少使用破坏性函数，防止发生副作用。 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. 类与对象 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 我们就不写什么有关动物的类了，下面给出的人力车的类 + +(defclass human-powered-conveyance () + ((velocity + :accessor velocity + :initarg :velocity) + (average-efficiency + :accessor average-efficiency + :initarg :average-efficiency)) + (:documentation "A human powered conveyance")) + +;; `defclass`，后面接类名，以及超类列表 +;; 再接着是槽的列表（槽有点像Java里的成员变量），最后是一些可选的特性 +;; 例如文档说明“:documentation” + +;; 如果超类列表为空，则默认该类继承于“standard-object”类（standard-object又是T的子类） +;; 这种默认行为是可以改变的，但你最好有一定的基础并且知道自己到底在干什么； +;; 参阅《The Art of the Metaobject Protocol》来了解更多信息。 + +(defclass bicycle (human-powered-conveyance) + ((wheel-size + :accessor wheel-size + :initarg :wheel-size + :documentation "Diameter of the wheel.") + (height + :accessor height + :initarg :height))) + +(defclass recumbent (bicycle) + ((chain-type + :accessor chain-type + :initarg :chain-type))) + +(defclass unicycle (human-powered-conveyance) nil) + +(defclass canoe (human-powered-conveyance) + ((number-of-rowers + :accessor number-of-rowers + :initarg :number-of-rowers))) + + +;; 在REPL中对human-powered-conveyance类调用`DESCRIBE`后结果如下： + +(describe 'human-powered-conveyance) + +; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE +; [symbol] +; +; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS +; HUMAN-POWERED-CONVEYANCE>: +; Documentation: +; A human powered conveyance +; Direct superclasses: STANDARD-OBJECT +; Direct subclasses: UNICYCLE, BICYCLE, CANOE +; Not yet finalized. +; Direct slots: +; VELOCITY +; Readers: VELOCITY +; Writers: (SETF VELOCITY) +; AVERAGE-EFFICIENCY +; Readers: AVERAGE-EFFICIENCY +; Writers: (SETF AVERAGE-EFFICIENCY) + +;; 注意到这些有用的返回信息——Common Lisp一直是一个交互式的系统。 + +;; 若要定义一个方法； +;; 注意，我们计算自行车轮子周长时使用了这样一个公式：C = d * pi + +(defmethod circumference ((object bicycle)) + (* pi (wheel-size object))) + +;; pi在Common Lisp中已经是一个内置的常量。 + +;; 假设我们已经知道了效率值（“efficiency value”）和船桨数大概呈对数关系； +;; 那么效率值的定义应当在构造器/初始化过程中就被完成。 + +;; 下面是一个Common Lisp构造实例时初始化实例的例子： + +(defmethod initialize-instance :after ((object canoe) &rest args) + (setf (average-efficiency object) (log (1+ (number-of-rowers object))))) + +;; 接着初构造一个实例并检查平均效率... + +(average-efficiency (make-instance 'canoe :number-of-rowers 15)) +; => 2.7725887 + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. 宏 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 宏可以让你扩展语法 + +;; 例如，Common Lisp并没有自带WHILE循环——所以让我们自己来为他添加一个； +;; 如果按照汇编程序的直觉来看，我们会这样写： + +(defmacro while (condition &body body) + "While `condition` is true, `body` is executed. + +`condition` is tested prior to each execution of `body`" + (let ((block-name (gensym))) + `(tagbody + (unless ,condition + (go ,block-name)) + (progn + ,@body) + ,block-name))) + +;; 让我们来看看它的高级版本： + +(defmacro while (condition &body body) + "While `condition` is true, `body` is executed. + +`condition` is tested prior to each execution of `body`" + `(loop while ,condition + do + (progn + ,@body))) + +;; 然而，在一个比较现代化的编译环境下，这样的WHILE是没有必要的； +;; LOOP形式的循环和这个WHILE同样的好，并且更易于阅读。 + +;; 注意反引号'`'，逗号','以及'@'这三个符号； +;; 反引号'`'是一种所谓“quasiquote”的引用类型的运算符，有了它，之后的逗号“,”才有意义。 +;; 逗号“,”意味着解除引用（unquote，即开始求值）； +;; “@”符号则表示将当前的参数插入到当前整个列表中。 +;;（译者注：要想真正用好、用对这三个符号，需要下一番功夫） +;;（甚至光看《实用 Common Lisp 编程》中关于宏的介绍都是不够的） +;;（建议再去读一读Paul Graham的两本著作《ANSI Common Lisp》和《On Lisp》） + +;; 函数`gensym`创建一个唯一的符号——这个符号确保不会出现在其他任何地方。 +;; 这样做是因为，宏是在编译期展开的 +;; 而在宏中声明的变量名极有可能和常规代码中使用的变量名发生冲突。 + +;; 可以去《实用 Common Lisp 编程》中阅读更多有关宏的内容。 +``` + + +## 拓展阅读 + +[继续阅读《实用 Common Lisp 编程》一书](http://www.gigamonkeys.com/book/) + + +## 致谢 + +非常感谢Scheme社区的人们，我基于他们的成果得以迅速的写出这篇有关Common Lisp的快速入门 +同时也感谢 +- [Paul Khuong](https://github.com/pkhuong) ，他提出了很多有用的点评。 + +##译者寄语 +“祝福那些将思想镶嵌在重重括号之内的人们。” diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown new file mode 100644 index 00000000..971c1be9 --- /dev/null +++ b/zh-cn/csharp-cn.html.markdown @@ -0,0 +1,799 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] + - ["Melvyn Laïly", "http://x2a.yt"] + - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] +translators: + - ["Jakukyo Friel", "http://weakish.github.io"] +filename: LearnCSharp-cn.cs +lang: zh-cn +--- + + +C#是一个优雅的、类型安全的面向对象语言。使用C#，开发者可以在.NET框架下构建安全、健壮的应用程序。 + +[更多关于C#的介绍](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx) + +```c# +// 单行注释以 // 开始 +/* +多行注释是这样的 +*/ +/// <summary> +/// XML文档注释 +/// </summary> + +// 声明应用用到的命名空间 +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Dynamic; +using System.Linq; +using System.Linq.Expressions; +using System.Net; +using System.Threading.Tasks; +using System.IO; + +// 定义作用域，将代码组织成包 +namespace Learning +{ + // 每个 .cs 文件至少需要包含一个和文件名相同的类 + // 你可以不这么干，但是这样不好。 + public class LearnCSharp + { + // 基本语法 - 如果你以前用过 Java 或 C++ 的话，可以直接跳到后文「有趣的特性」 + public static void Syntax() + { + // 使用 Console.WriteLine 打印信息 + Console.WriteLine("Hello World"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // 使用 Console.Write 打印，不带换行符号 + Console.Write("Hello "); + Console.Write("World"); + + /////////////////////////////////////////////////// + // 类型和变量 + // + // 使用 <type> <name> 定义变量 + /////////////////////////////////////////////////// + + // Sbyte - 有符号 8-bit 整数 + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - 无符号 8-bit 整数 + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - 16-bit 整数 + // 有符号 - (-32,768 <= short <= 32,767) + // 无符号 - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Integer - 32-bit 整数 + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - 64-bit 整数 + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // 数字默认为 int 或 uint （取决于尺寸） + // 使用 L 标明变量值类型为long 或 ulong + + // Double - 双精度 64-bit IEEE 754 浮点数 + double fooDouble = 123.4; // 精度: 15-16 位 + + // Float - 单精度 32-bit IEEE 754 浮点数 + float fooFloat = 234.5f; // 精度: 7 位 + // 使用 f 标明变量值类型为float + + // Decimal - 128-bits 数据类型，比其他浮点类型精度更高 + // 适合财务、金融 + decimal fooDecimal = 150.3m; + + // 布尔值 - true & false + bool fooBoolean = true; // 或 false + + // Char - 单个 16-bit Unicode 字符 + char fooChar = 'A'; + + // 字符串 -- 和前面的基本类型不同，字符串不是值，而是引用。 + // 这意味着你可以将字符串设为null。 + string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; + Console.WriteLine(fooString); + + // 你可以通过索引访问字符串的每个字符： + char charFromString = fooString[1]; // => 'e' + // 字符串不可修改: fooString[1] = 'X' 是行不通的; + + // 根据当前的locale设定比较字符串，大小写不敏感 + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // 基于sprintf的字符串格式化 + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // 日期和格式 + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // 使用 @ 符号可以创建跨行的字符串。使用 "" 来表示 " + string bazString = @"Here's some stuff +on a new line! ""Wow!"", the masses cried"; + + // 使用const或read-only定义常量 + // 常量在编译期演算 + const int HOURS_I_WORK_PER_WEEK = 9001; + + /////////////////////////////////////////////////// + // 数据结构 + /////////////////////////////////////////////////// + + // 数组 - 从0开始计数 + // 声明数组时需要确定数组长度 + // 声明数组的格式如下： + // <datatype>[] <var name> = new <datatype>[<array size>]; + int[] intArray = new int[10]; + + // 声明并初始化数组的其他方式： + int[] y = { 9000, 1000, 1337 }; + + // 访问数组的元素 + Console.WriteLine("intArray @ 0: " + intArray[0]); + // 数组可以修改 + intArray[1] = 1; + + // 列表 + // 列表比数组更常用，因为列表更灵活。 + // 声明列表的格式如下： + // List<datatype> <var name> = new List<datatype>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // i + // <>用于泛型 - 参考下文 + + // 列表无默认值 + // 访问列表元素时必须首先添加元素 + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + // 其他数据结构： + // 堆栈/队列 + // 字典 (哈希表的实现) + // 哈希集合 + // 只读集合 + // 元组 (.Net 4+) + + /////////////////////////////////////// + // 操作符 + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // 多重声明的简写形式 + + // 算术直截了当 + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // 取余 + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // 比较操作符 + Console.WriteLine("3 == 2? " + (3 == 2)); // => false + Console.WriteLine("3 != 2? " + (3 != 2)); // => true + Console.WriteLine("3 > 2? " + (3 > 2)); // => true + Console.WriteLine("3 < 2? " + (3 < 2)); // => false + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true + + // 位操作符 + /* + ~ 取反 + << 左移（有符号） + >> 右移（有符号） + & 与 + ^ 异或 + | 或 + */ + + // 自增、自减 + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. 事后自增 + Console.WriteLine(++i); //i = 2. 事先自增 + Console.WriteLine(i--); //i = 1. 事后自减 + Console.WriteLine(--i); //i = 0. 事先自减 + + /////////////////////////////////////// + // 控制结构 + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // 类似C的if语句 + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // 三元表达式 + // 简单的 if/else 语句可以写成： + // <条件> ? <真> : <假> + int toCompare = 17; + string isTrue = toCompare == 17 ? "True" : "False"; + + // While 循环 + int fooWhile = 0; + while (fooWhile < 100) + { + //迭代 100 次, fooWhile 0->99 + fooWhile++; + } + + // Do While 循环 + int fooDoWhile = 0; + do + { + //迭代 100 次, fooDoWhile 0->99 + fooDoWhile++; + } while (fooDoWhile < 100); + + //for 循环结构 => for(<初始条件>; <条件>; <步>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + //迭代10次, fooFor 0->9 + } + + // foreach循环 + // foreach 循环结构 => foreach(<迭代器类型> <迭代器> in <可枚举结构>) + // foreach 循环适用于任何实现了 IEnumerable 或 IEnumerable<T> 的对象。 + // .Net 框架下的集合类型(数组, 列表, 字典...) + // 都实现了这些接口 + // (下面的代码中，ToCharArray()可以删除，因为字符串同样实现了IEnumerable) + foreach (char character in "Hello World".ToCharArray()) + { + //迭代字符串中的所有字符 + } + + // Switch 语句 + // switch 适用于 byte、short、char和int 数据类型。 + // 同样适用于可枚举的类型 + // 包括字符串类, 以及一些封装了原始值的类： + // Character、Byte、Short和Integer。 + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + // 你可以一次匹配多个case语句 + // 但是你在添加case语句后需要使用break + // （否则你需要显式地使用goto case x语句） + case 6: + case 7: + case 8: + monthString = "Summer time!!"; + break; + default: + monthString = "Some other month"; + break; + } + + /////////////////////////////////////// + // 转换、指定数据类型 + /////////////////////////////////////// + + // 转换类型 + + // 转换字符串为整数 + // 转换失败会抛出异常 + int.Parse("123");//返回整数类型的"123" + + // TryParse会尝试转换类型，失败时会返回缺省类型 + // 例如 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // Funciton is boolean + Console.WriteLine(tryInt); // 123 + + // 转换整数为字符串 + // Convert类提供了一系列便利转换的方法 + Convert.ToString(123); + // or + tryInt.ToString(); + } + + /////////////////////////////////////// + // 类 + /////////////////////////////////////// + public static void Classes() + { + // 参看文件尾部的对象声明 + + // 使用new初始化对象 + Bicycle trek = new Bicycle(); + + // 调用对象的方法 + trek.SpeedUp(3); // 你应该一直使用setter和getter方法 + trek.Cadence = 100; + + // 查看对象的信息. + Console.WriteLine("trek info: " + trek.Info()); + + // 实例化一个新的Penny Farthing + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } // 结束main方法 + + // 终端程序 终端程序必须有一个main方法作为入口 + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // 有趣的特性 + // + + // 默认方法签名 + + public // 可见性 + static // 允许直接调用类，无需先创建实例 + int, //返回值 + MethodSignatures( + int maxCount, // 第一个变量，类型为整型 + int count = 0, // 如果没有传入值，则缺省值为0 + int another = 3, + params string[] otherParams // 捕获其他参数 + ) + { + return -1; + } + + // 方法可以重名，只要签名不一样 + public static void MethodSignature(string maxCount) + { + } + + //泛型 + // TKey和TValue类由用用户调用函数时指定。 + // 以下函数模拟了Python的SetDefault + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // 你可以限定传入值的范围 + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // 我们可以进行迭代，因为T是可枚举的 + foreach (var item in toPrint) + // ittm为整数 + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // 可选参数 + MethodSignatures(3, 1, 3, "Some", "Extra", "Strings"); + MethodSignatures(3, another: 3); // 显式指定参数，忽略可选参数 + + // 扩展方法 + int i = 3; + i.Print(); // 参见下面的定义 + + // 可为null的类型 对数据库交互、返回值很有用 + // 任何值类型 (i.e. 不为类) 添加后缀 ? 后会变为可为null的值 + // <类型>? <变量名> = <值> + int? nullable = null; // Nullable<int> 的简写形式 + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // 不为null时返回真 + // ?? 是用于指定默认值的语法糖 + // 以防变量为null的情况 + int notNullable = nullable ?? 0; // 0 + + // 变量类型推断 - 你可以让编译器推断变量类型: + var magic = "编译器确定magic是一个字符串，所以仍然是类型安全的"; + // magic = 9; // 不工作，因为magic是字符串，而不是整数。 + + // 泛型 + // + var phonebook = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // 在电话簿中加入新条目 + }; + + // 调用上面定义为泛型的SETDEFAULT + Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // 没有电话 + // 你不用指定TKey、TValue，因为它们会被隐式地推导出来 + Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555 + + // lambda表达式 - 允许你用一行代码搞定函数 + Func<int, int> square = (x) => x * x; // 最后一项为返回值 + Console.WriteLine(square(3)); // 9 + + // 可抛弃的资源管理 - 让你很容易地处理未管理的资源 + // 大多数访问未管理资源 (文件操作符、设备上下文, etc.)的对象 + // 都实现了IDisposable接口。 + // using语句会为你清理IDisposable对象。 + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("这里没有什么可疑的东西"); + // 在作用域的结尾，资源会被回收 + // （即使有异常抛出，也一样会回收） + } + + // 并行框架 + // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // 为每个请求新开一个线程 + // 在运行下一步前合并结果 + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads + website => + { + // Do something that takes a long time on the file + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // 直到所有的请求完成后才会运行下面的代码 + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // 动态对象（配合其他语言使用很方便） + dynamic student = new ExpandoObject(); + student.FirstName = "First Name"; // 不需要先定义类！ + + // 你甚至可以添加方法（接受一个字符串，输出一个字符串） + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - 几乎所有的集合都实现了它， + // 带给你 Map / Filter / Reduce 风格的方法 + var bikes = new List<Bicycle>(); + bikes.Sort(); // Sorts the array + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // 根据车轮数排序 + var result = bikes + .Where(b => b.Wheels > 3) // 筛选 - 可以连锁使用 （返回IQueryable) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // Map - 这里我们使用了select，所以结果是IQueryable<string> + + var sum = bikes.Sum(b => b.Wheels); // Reduce - 计算集合中的轮子总数 + + // 创建一个包含基于自行车的一些参数生成的隐式对象的列表 + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // 很难演示，但是编译器在代码编译完成前就能推导出以上对象的类型 + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + // ASPARALLEL + // 邪恶的特性 —— 组合了linq和并行操作 + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // 以上代码会并发地运行。会自动新开线程，分别计算结果。 + // 适用于多核、大数据量的场景。 + + // LINQ - 将IQueryable<T>映射到存储，延缓执行 + // 例如 LinqToSql 映射数据库, LinqToXml 映射XML文档 + var db = new BikeRespository(); + + // 执行被延迟了，这对于查询数据库来说很好 + var filter = db.Bikes.Where(b => b.HasTassles); // 不运行查询 + if (42 > 6) // 你可以不断地增加筛选，包括有条件的筛选，例如用于“高级搜索”功能 + filter = filter.Where(b => b.IsBroken); // 不运行查询 + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // 仍然不运行查询 + + // 现在运行查询，运行查询的时候会打开一个读取器，所以你迭代的是一个副本 + foreach (string bike in query) + Console.WriteLine(result); + + + + } + + } // 结束LearnCSharp类 + + // 你可以在同一个 .cs 文件中包含其他类 + + public static class Extensions + { + // 扩展函数 + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + // 声明类的语法： + // <public/private/protected/internal> class <类名>{ + // //数据字段, 构造器, 内部函数. + / // 在Java中函数被称为方法。 + // } + + public class Bicycle + { + // 自行车的字段、变量 + public int Cadence // Public: 任何地方都可以访问 + { + get // get - 定义获取属性的方法 + { + return _cadence; + } + set // set - 定义设置属性的方法 + { + _cadence = value; // value是被传递给setter的值 + } + } + private int _cadence; + + protected virtual int Gear // 类和子类可以访问 + { + get; // 创建一个自动属性，无需成员字段 + set; + } + + internal int Wheels // Internal:在同一程序集内可以访问 + { + get; + private set; // 可以给get/set方法添加修饰符 + } + + int _speed; // 默认为private: 只可以在这个类内访问，你也可以使用`private`关键词 + public string Name { get; set; } + + // enum类型包含一组常量 + // 它将名称映射到值（除非特别说明，是一个整型） + // enmu元素的类型可以是byte、sbyte、short、ushort、int、uint、long、ulong。 + // enum不能包含相同的值。 + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, //你可以显式地赋值 + Gitane // 43 + } + // 我们在Bicycle类中定义的这个类型，所以它是一个内嵌类型。 + // 这个类以外的代码应当使用`Bicycle.Brand`来引用。 + + public BikeBrand Brand; // 声明一个enum类型之后，我们可以声明这个类型的字段 + + // 静态方法的类型为自身，不属于特定的对象。 + // 你无需引用对象就可以访问他们。 + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + static public int BicyclesCreated = 0; + + // 只读值在运行时确定 + // 它们只能在声明或构造器内被赋值 + readonly bool _hasCardsInSpokes = false; // read-only private + + // 构造器是创建类的一种方式 + // 下面是一个默认的构造器 + public Bicycle() + { + this.Gear = 1; // 你可以使用关键词this访问对象的成员 + Cadence = 50; // 不过你并不总是需要它 + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // 另一个构造器的例子（包含参数） + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // 首先调用base + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // 构造器可以连锁使用 + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // 函数语法 + // <public/private/protected> <返回值> <函数名称>(<参数>) + + // 类可以为字段实现 getters 和 setters 方法 for their fields + // 或者可以实现属性（C#推荐使用这个） + // 方法的参数可以有默认值 + // 在有默认值的情况下，调用方法的时候可以省略相应的参数 + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // 属性可以访问和设置值 + // 当只需要访问数据的时候，考虑使用属性。 + // 属性可以定义get和set，或者是同时定义两者 + private bool _hasTassles; // private variable + public bool HasTassles // public accessor + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // 你可以在一行之内定义自动属性 + // 这个语法会自动创建后备字段 + // 你可以给getter或setter设置访问修饰符 + // 以便限制它们的访问 + public bool IsBroken { get; private set; } + + // 属性的实现可以是自动的 + public int FrameSize + { + get; + // 你可以给get或set指定访问修饰符 + // 以下代码意味着只有Bicycle类可以调用Framesize的set + private set; + } + + //显示对象属性的方法 + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // 方法可以是静态的。通常用于辅助方法。 + public static bool DidWeCreateEnoughBycles() + { + // 在静态方法中，你只能引用类的静态成员 + return BicyclesCreated > 9000; + } // 如果你的类只需要静态成员，考虑将整个类作为静态类。 + + + } // Bicycle类结束 + + // PennyFarthing是Bicycle的一个子类 + class PennyFarthing : Bicycle + { + // (Penny Farthings是一种前轮很大的自行车。没有齿轮。） + + // 调用父构造器 + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + throw new ArgumentException("你不可能在PennyFarthing上切换齿轮"); + } + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // 调用父方法 + return result; + } + } + + // 接口只包含成员的签名，而没有实现。 + interface IJumpable + { + void Jump(int meters); // 所有接口成员是隐式地公开的 + } + + interface IBreakable + { + bool Broken { get; } // 接口可以包含属性、方法和事件 + } + + // 类只能继承一个类，但是可以实现任意数量的接口 + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// 连接数据库，一个 LinqToSql的示例。 + /// EntityFramework Code First 很棒 (类似 Ruby的 ActiveRecord, 不过是双向的) + /// http://msdn.microsoft.com/en-us/data/jj193542.aspx + /// </summary> + public class BikeRespository : DbSet + { + public BikeRespository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // 结束 Namespace +``` + +## 没有涉及到的主题 + + * Flags + * Attributes + * 静态属性 + * Exceptions, Abstraction + * ASP.NET (Web Forms/MVC/WebMatrix) + * Winforms + * Windows Presentation Foundation (WPF) + +## 扩展阅读 + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx) diff --git a/zh-cn/css-cn.html.markdown b/zh-cn/css-cn.html.markdown new file mode 100644 index 00000000..dc6dcc4f --- /dev/null +++ b/zh-cn/css-cn.html.markdown @@ -0,0 +1,212 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Jakukyo Friel", "https://weakish.github.io"] +lang: zh-cn +filename: learncss-cn.css +--- + +早期的web没有样式，只是单纯的文本。通过CSS，可以实现网页样式和内容的分离。 + +简单来说，CSS可以指定HTML页面上的元素所使用的样式。 + +和其他语言一样，CSS有很多版本。最新的版本是CSS 3. CSS 2.0兼容性最好。 + +你可以使用[dabblet](http://dabblet.com/)来在线测试CSS的效果。 + +```css +/* 注释 */ + +/* #################### + ## 选择器 + ####################*/ + +/* 一般而言，CSS的声明语句非常简单。 */ +选择器 { 属性: 值; /* 更多属性...*/ } + +/* 选择器用于指定页面上的元素。 + +针对页面上的所有元素。 */ +* { color:red; } + +/* +假定页面上有这样一个元素 + +<div class='some-class class2' id='someId' attr='value' /> +*/ + +/* 你可以通过类名来指定它 */ +.some-class { } + +/* 给出所有类名 */ +.some-class.class2 { } + +/* 标签名 */ +div { } + +/* id */ +#someId { } + +/* 由于元素包含attr属性，因此也可以通过这个来指定 */ +[attr] { font-size:smaller; } + +/* 以及有特定值的属性 */ +[attr='value'] { font-size:smaller; } + +/* 通过属性的值的开头指定 */ +[attr^='val'] { font-size:smaller; } + +/* 通过属性的值的结尾来指定 */ +[attr$='ue'] { font-size:smaller; } + +/* 通过属性的值的部分来指定 */ +[attr~='lu'] { font-size:smaller; } + + +/* 你可以把这些全部结合起来，注意不同部分间不应该有空格，否则会改变语义 */ +div.some-class[attr$='ue'] { } + +/* 你也可以通过父元素来指定。*/ + +/* 某个元素是另一个元素的直接子元素 */ +div.some-parent > .class-name {} + +/* 或者通过该元素的祖先元素 */ +div.some-parent .class-name {} + +/* 注意，去掉空格后语义就不同了。 +你能说出哪里不同么？ */ +div.some-parent.class-name {} + +/* 你可以选择某元素前的相邻元素 */ +.i-am-before + .this-element { } + +/* 某元素之前的同级元素（相邻或不相邻） */ +.i-am-any-before ~ .this-element {} + +/* 伪类允许你基于页面的行为指定元素（而不是基于页面结构） */ + +/* 例如，当鼠标悬停在某个元素上时 */ +:hover {} + +/* 已访问过的链接*/ +:visited {} + +/* 未访问过的链接*/ +:link {} + +/* 当前焦点的input元素 */ +:focus {} + + +/* #################### + ## 属性 + ####################*/ + +选择器 { + + /* 单位 */ + width: 50%; /* 百分比 */ + font-size: 2em; /* 当前字体大小的两倍 */ + width: 200px; /* 像素 */ + font-size: 20pt; /* 点 */ + width: 5cm; /* 厘米 */ + width: 50mm; /* 毫米 */ + width: 5in; /* 英尺 */ + + /* 颜色 */ + background-color: #F6E; /* 短16位 */ + background-color: #F262E2; /* 长16位 */ + background-color: tomato; /* 颜色名称 */ + background-color: rgb(255, 255, 255); /* rgb */ + background-color: rgb(10%, 20%, 50%); /* rgb 百分比 */ + background-color: rgba(255, 0, 0, 0.3); /* rgb 加透明度 */ + + /* 图片 */ + background-image: url(/path-to-image/image.jpg); + + /* 字体 */ + font-family: Arial; + font-family: "Courier New"; /* 使用双引号包裹含空格的字体名称 */ + font-family: "Courier New", Trebuchet, Arial; /* 如果第一个 + 字体没找到，浏览器会使用第二个字体，一次类推 */ +} + +``` + +## 使用 + +CSS文件使用 `.css` 后缀。 + +```xml +<!-- 你需要在文件的 <head> 引用CSS文件 --> +<link rel='stylesheet' type='text/css' href='filepath/filename.css' /> + +<!-- 你也可以在标记中内嵌CSS。不过强烈建议不要这么干。 --> +<style> + 选择器 { 属性:值; } +</style> + +<!-- 也可以直接使用元素的style属性。 +这是你最不该干的事情。 --> +<div style='property:value;'> +</div> + +``` + +## 优先级 + +同一个元素可能被多个不同的选择器指定，因此可能会有冲突。 + +假定CSS是这样的： + +```css +/*A*/ +p.class1[attr='value'] + +/*B*/ +p.class1 {} + +/*C*/ +p.class2 {} + +/*D*/ +p {} + +/*E*/ +p { property: value !important; } + +``` + +然后标记语言为： + +```xml +<p style='/*F*/ property:value;' class='class1 class2' attr='value'> +</p> +``` + +那么将会按照下面的顺序应用风格： + + +* `E` 优先级最高，因为它使用了 `!important`，除非很有必要，尽量避免使用这个。 +* `F` 其次，因为它是嵌入的风格。 +* `A` 其次，因为它比其他指令更具体。 +* `C` 其次，虽然它的具体程度和`B`一样，但是它在`B`之后。 +* 接下来是 `B`。 +* 最后是 `D`。 + +## 兼容性 + +CSS2 的绝大部分特性兼容各种浏览器和设备。现在 CSS3 的兼容性也越来越好了。 +但是兼容性问题仍然是需要留意的一个问题。 + +[QuirksMode CSS](http://www.quirksmode.org/css/)是关于这方面最好的资源。 + +## 扩展阅读 + +* [理解CSS的风格优先级: 特定性, 继承和层叠](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) diff --git a/zh-cn/dart-cn.html.markdown b/zh-cn/dart-cn.html.markdown new file mode 100644 index 00000000..6a6562bc --- /dev/null +++ b/zh-cn/dart-cn.html.markdown @@ -0,0 +1,499 @@ +--- +language: dart +lang: zh-cn +filename: learndart-cn.dart +contributors: + - ["Joao Pedrosa", "https://github.com/jpedrosa/"] +translators: + - ["Guokai Han", "https://github.com/hanguokai/"] +--- + +Dart 是编程语言王国的新人。 +它借鉴了许多其他主流语言，并且不会偏离它的兄弟语言 JavaScript 太多。 +就像 JavaScript 一样，Dart 的目标是提供良好的浏览器集成。 + +Dart 最有争议的特性必然是它的可选类型。 + +```javascript +import "dart:collection"; +import "dart:math" as DM; + +// 欢迎进入15分钟的 Dart 学习。 http://www.dartlang.org/ +// 这是一个可实际执行的向导。你可以用 Dart 运行它 +// 或者在线执行! 可以把代码复制/粘贴到这个网站。 http://try.dartlang.org/ + +// 函数声明和方法声明看起来一样。 +// 函数声明可以嵌套。声明使用这种 name() {} 的形式， +// 或者 name() => 单行表达式; 的形式。 +// 右箭头的声明形式会隐式地返回表达式的结果。 +example1() { + example1nested1() { + example1nested2() => print("Example1 nested 1 nested 2"); + example1nested2(); + } + example1nested1(); +} + +// 匿名函数没有函数名。 +example2() { + example2nested1(fn) { + fn(); + } + example2nested1(() => print("Example2 nested 1")); +} + +// 当声明函数类型的参数的时候，声明中可以包含 +// 函数参数需要的参数，指定所需的参数名即可。 +example3() { + example3nested1(fn(informSomething)) { + fn("Example3 nested 1"); + } + example3planB(fn) { // 或者不声明函数参数的参数 + fn("Example3 plan B"); + } + example3nested1((s) => print(s)); + example3planB((s) => print(s)); +} + +// 函数有可以访问到外层变量的闭包。 +var example4Something = "Example4 nested 1"; +example4() { + example4nested1(fn(informSomething)) { + fn(example4Something); + } + example4nested1((s) => print(s)); +} + +// 下面这个包含 sayIt 方法的类声明，同样有一个可以访问外层变量的闭包， +// 就像前面的函数一样。 +var example5method = "Example5 sayIt"; +class Example5Class { + sayIt() { + print(example5method); + } +} +example5() { + // 创建一个 Example5Class 类的匿名实例， + // 并调用它的 sayIt 方法。 + new Example5Class().sayIt(); +} + +// 类的声明使用这种形式 class name { [classBody] }. +// classBody 中可以包含实例方法和变量， +// 还可以包含类方法和变量。 +class Example6Class { + var example6InstanceVariable = "Example6 instance variable"; + sayIt() { + print(example6InstanceVariable); + } +} +example6() { + new Example6Class().sayIt(); +} + +// 类方法和变量使用 static 关键词声明。 +class Example7Class { + static var example7ClassVariable = "Example7 class variable"; + static sayItFromClass() { + print(example7ClassVariable); + } + sayItFromInstance() { + print(example7ClassVariable); + } +} +example7() { + Example7Class.sayItFromClass(); + new Example7Class().sayItFromInstance(); +} + +// 字面量非常方便，但是对于在函数/方法的外层的字面量有一个限制， +// 类的外层或外面的字面量必需是常量。 +// 字符串和数字默认是常量。 +// 但是 array 和 map 不是。他们需要用 "const" 声明为常量。 +var example8A = const ["Example8 const array"], + example8M = const {"someKey": "Example8 const map"}; +example8() { + print(example8A[0]); + print(example8M["someKey"]); +} + +// Dart 中的循环使用标准的 for () {} 或 while () {} 的形式， +// 以及更加现代的 for (.. in ..) {} 的形式, 或者 +// 以 forEach 开头并具有许多特性支持的函数回调的形式。 +var example9A = const ["a", "b"]; +example9() { + for (var i = 0; i < example9A.length; i++) { + print("Example9 for loop '${example9A[i]}'"); + } + var i = 0; + while (i < example9A.length) { + print("Example9 while loop '${example9A[i]}'"); + i++; + } + for (var e in example9A) { + print("Example9 for-in loop '${e}'"); + } + example9A.forEach((e) => print("Example9 forEach loop '${e}'")); +} + +// 遍历字符串中的每个字符或者提取其子串。 +var example10S = "ab"; +example10() { + for (var i = 0; i < example10S.length; i++) { + print("Example10 String character loop '${example10S[i]}'"); + } + for (var i = 0; i < example10S.length; i++) { + print("Example10 substring loop '${example10S.substring(i, i + 1)}'"); + } +} + +// 支持两种数字格式 int 和 double 。 +example11() { + var i = 1 + 320, d = 3.2 + 0.01; + print("Example11 int ${i}"); + print("Example11 double ${d}"); +} + +// DateTime 提供了日期/时间的算法。 +example12() { + var now = new DateTime.now(); + print("Example12 now '${now}'"); + now = now.add(new Duration(days: 1)); + print("Example12 tomorrow '${now}'"); +} + +// 支持正则表达式。 +example13() { + var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$"); + match(s) { + if (re.hasMatch(s)) { + print("Example13 regexp matches '${s}'"); + } else { + print("Example13 regexp doesn't match '${s}'"); + } + } + match(s1); + match(s2); +} + +// 布尔表达式必需被解析为 true 或 false， +// 因为不支持隐式转换。 +example14() { + var v = true; + if (v) { + print("Example14 value is true"); + } + v = null; + try { + if (v) { + // 不会执行 + } else { + // 不会执行 + } + } catch (e) { + print("Example14 null value causes an exception: '${e}'"); + } +} + +// try/catch/finally 和 throw 语句用于异常处理。 +// throw 语句可以使用任何对象作为参数。 +example15() { + try { + try { + throw "Some unexpected error."; + } catch (e) { + print("Example15 an exception: '${e}'"); + throw e; // Re-throw + } + } catch (e) { + print("Example15 catch exception being re-thrown: '${e}'"); + } finally { + print("Example15 Still run finally"); + } +} + +// 要想有效地动态创建长字符串， +// 应该使用 StringBuffer。 或者 join 一个字符串的数组。 +example16() { + var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e; + for (e in a) { sb.write(e); } + print("Example16 dynamic string created with " + "StringBuffer '${sb.toString()}'"); + print("Example16 join string array '${a.join()}'"); +} + +// 字符串连接只需让相邻的字符串字面量挨着， +// 不需要额外的操作符。 +example17() { + print("Example17 " + "concatenate " + "strings " + "just like that"); +} + +// 字符串使用单引号或双引号做分隔符，二者并没有实际的差异。 +// 这种灵活性可以很好地避免内容中需要转义分隔符的情况。 +// 例如，字符串内容里的 HTML 属性使用了双引号。 +example18() { + print('Example18 <a href="etc">' + "Don't can't I'm Etc" + '</a>'); +} + +// 用三个单引号或三个双引号表示的字符串 +// 可以跨越多行，并且包含行分隔符。 +example19() { + print('''Example19 <a href="etc"> +Example19 Don't can't I'm Etc +Example19 </a>'''); +} + +// 字符串可以使用 $ 字符插入内容。 +// 使用 $ { [expression] } 的形式，表达式的值会被插入到字符串中。 +// $ 跟着一个变量名会插入变量的值。 +// 如果要在字符串中插入 $ ，可以使用 \$ 的转义形式代替。 +example20() { + var s1 = "'\${s}'", s2 = "'\$s'"; + print("Example20 \$ interpolation ${s1} or $s2 works."); +} + +// 可选类型允许作为 API 的标注，并且可以辅助 IDE， +// 这样 IDE 可以更好地提供重构、自动完成和错误检测功能。 +// 目前为止我们还没有声明任何类型，并且程序运行地很好。 +// 事实上，类型在运行时会被忽略。 +// 类型甚至可以是错的，并且程序依然可以执行， +// 好像和类型完全无关一样。 +// 有一个运行时参数可以让程序进入检查模式，它会在运行时检查类型错误。 +// 这在开发时很有用，但是由于增加了额外的检查会使程序变慢， +// 因此应该避免在部署时使用。 +class Example21 { + List<String> _names; + Example21() { + _names = ["a", "b"]; + } + List<String> get names => _names; + set names(List<String> list) { + _names = list; + } + int get length => _names.length; + void add(String name) { + _names.add(name); + } +} +void example21() { + Example21 o = new Example21(); + o.add("c"); + print("Example21 names '${o.names}' and length '${o.length}'"); + o.names = ["d", "e"]; + print("Example21 names '${o.names}' and length '${o.length}'"); +} + +// 类的继承形式是 class name extends AnotherClassName {} 。 +class Example22A { + var _name = "Some Name!"; + get name => _name; +} +class Example22B extends Example22A {} +example22() { + var o = new Example22B(); + print("Example22 class inheritance '${o.name}'"); +} + +// 类也可以使用 mixin 的形式 ： +// class name extends SomeClass with AnotherClassName {}. +// 必需继承某个类才能 mixin 另一个类。 +// 当前 mixin 的模板类不能有构造函数。 +// Mixin 主要是用来和辅助的类共享方法的， +// 这样单一继承就不会影响代码复用。 +// Mixin 声明在类定义的 "with" 关键词后面。 +class Example23A {} +class Example23Utils { + addTwo(n1, n2) { + return n1 + n2; + } +} +class Example23B extends Example23A with Example23Utils { + addThree(n1, n2, n3) { + return addTwo(n1, n2) + n3; + } +} +example23() { + var o = new Example23B(), r1 = o.addThree(1, 2, 3), + r2 = o.addTwo(1, 2); + print("Example23 addThree(1, 2, 3) results in '${r1}'"); + print("Example23 addTwo(1, 2) results in '${r2}'"); +} + +// 类的构造函数名和类名相同，形式为 +// SomeClass() : super() {}, 其中 ": super()" 的部分是可选的， +// 它用来传递参数给父类的构造函数。 +class Example24A { + var _value; + Example24A({value: "someValue"}) { + _value = value; + } + get value => _value; +} +class Example24B extends Example24A { + Example24B({value: "someOtherValue"}) : super(value: value); +} +example24() { + var o1 = new Example24B(), + o2 = new Example24B(value: "evenMore"); + print("Example24 calling super during constructor '${o1.value}'"); + print("Example24 calling super during constructor '${o2.value}'"); +} + +// 对于简单的类，有一种设置构造函数参数的快捷方式。 +// 只需要使用 this.parameterName 的前缀， +// 它就会把参数设置为同名的实例变量。 +class Example25 { + var value, anotherValue; + Example25({this.value, this.anotherValue}); +} +example25() { + var o = new Example25(value: "a", anotherValue: "b"); + print("Example25 shortcut for constructor '${o.value}' and " + "'${o.anotherValue}'"); +} + +// 可以在大括号 {} 中声明命名参数。 +// 大括号 {} 中声明的参数的顺序是随意的。 +// 在中括号 [] 中声明的参数也是可选的。 +example26() { + var _name, _surname, _email; + setConfig1({name, surname}) { + _name = name; + _surname = surname; + } + setConfig2(name, [surname, email]) { + _name = name; + _surname = surname; + _email = email; + } + setConfig1(surname: "Doe", name: "John"); + print("Example26 name '${_name}', surname '${_surname}', " + "email '${_email}'"); + setConfig2("Mary", "Jane"); + print("Example26 name '${_name}', surname '${_surname}', " + "email '${_email}'"); +} + +// 使用 final 声明的变量只能被设置一次。 +// 在类里面，final 实例变量可以通过常量的构造函数参数设置。 +class Example27 { + final color1, color2; + // 更灵活一点的方法是在冒号 : 后面设置 final 实例变量。 + Example27({this.color1, color2}) : color2 = color2; +} +example27() { + final color = "orange", o = new Example27(color1: "lilac", color2: "white"); + print("Example27 color is '${color}'"); + print("Example27 color is '${o.color1}' and '${o.color2}'"); +} + +// 要导入一个库，使用 import "libraryPath" 的形式，或者如果要导入的是 +// 核心库使用 import "dart:libraryName" 。还有一个称为 "pub" 的包管理工具， +// 它使用 import "package:packageName" 的约定形式。 +// 看下这个文件顶部的 import "dart:collection"; 语句。 +// 导入语句必需在其它代码声明之前出现。IterableBase 来自于 dart:collection 。 +class Example28 extends IterableBase { + var names; + Example28() { + names = ["a", "b"]; + } + get iterator => names.iterator; +} +example28() { + var o = new Example28(); + o.forEach((name) => print("Example28 '${name}'")); +} + +// 对于控制流语句，我们有： +// * 必需带 break 的标准 switch 语句 +// * if-else 和三元操作符 ..?..:.. +// * 闭包和匿名函数 +// * break, continue 和 return 语句 +example29() { + var v = true ? 30 : 60; + switch (v) { + case 30: + print("Example29 switch statement"); + break; + } + if (v < 30) { + } else if (v > 30) { + } else { + print("Example29 if-else statement"); + } + callItForMe(fn()) { + return fn(); + } + rand() { + v = new DM.Random().nextInt(50); + return v; + } + while (true) { + print("Example29 callItForMe(rand) '${callItForMe(rand)}'"); + if (v != 30) { + break; + } else { + continue; + } + // 不会到这里。 + } +} + +// 解析 int，把 double 转成 int，或者使用 ~/ 操作符在除法计算时仅保留整数位。 +// 让我们也来场猜数游戏吧。 +example30() { + var gn, tooHigh = false, + n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0; + top = top ~/ 6; + gn = new DM.Random().nextInt(top + 1); // +1 because nextInt top is exclusive + print("Example30 Guess a number between 0 and ${top}"); + guessNumber(i) { + if (n == gn) { + print("Example30 Guessed right! The number is ${gn}"); + } else { + tooHigh = n > gn; + print("Example30 Number ${n} is too " + "${tooHigh ? 'high' : 'low'}. Try again"); + } + return n == gn; + } + n = (top - bottom) ~/ 2; + while (!guessNumber(n)) { + if (tooHigh) { + top = n - 1; + } else { + bottom = n + 1; + } + n = bottom + ((top - bottom) ~/ 2); + } +} + +// 程序的唯一入口点是 main 函数。 +// 在程序开始执行 main 函数之前，不期望执行任何外层代码。 +// 这样可以帮助程序更快地加载，甚至仅惰性加载程序启动时需要的部分。 +main() { + print("Learn Dart in 15 minutes!"); + [example1, example2, example3, example4, example5, example6, example7, + example8, example9, example10, example11, example12, example13, example14, + example15, example16, example17, example18, example19, example20, + example21, example22, example23, example24, example25, example26, + example27, example28, example29, example30 + ].forEach((ef) => ef()); +} + +``` + +## 延伸阅读 + +Dart 有一个综合性网站。它涵盖了 API 参考、入门向导、文章以及更多， +还包括一个有用的在线试用 Dart 页面。 +http://www.dartlang.org/ +http://try.dartlang.org/ + + + diff --git a/zh-cn/elisp-cn.html.markdown b/zh-cn/elisp-cn.html.markdown index d9a8ce35..06f38d77 100755..100644 --- a/zh-cn/elisp-cn.html.markdown +++ b/zh-cn/elisp-cn.html.markdown @@ -3,12 +3,15 @@ language: elisp contributors:
- ["Bastien Guerry", "http://bzg.fr"]
translators:
- - ["Chenbo Li", "http://binarythink.net"]
-filename: learn-emacs-lisp.el
+ - ["Chenbo Li", "http://binarythink.net"]
+filename: learn-emacs-lisp-zh.el
+lang: zh-cn
---
```scheme
-;; 15分钟学会Emacs Lisp (v0.2a) （作者：bzg，https://github.com/bzg 译者：lichenbo，http://douban.com/people/lichenbo）
+;; 15分钟学会Emacs Lisp (v0.2a)
+;;（作者：bzg，https://github.com/bzg
+;; 译者：lichenbo，http://douban.com/people/lichenbo）
;;
;; 请先阅读Peter Norvig的一篇好文:
;; http://norvig.com/21-days.html
@@ -129,7 +132,7 @@ filename: learn-emacs-lisp.el ;; `C-xC-e' 这时屏幕上会显示两个窗口，而光标此时位于*test* buffer内
;; 用鼠标单击上面的buffer就会使光标移回。
-;; 或者你可以使用 `C-xo' 是的光标跳到另一个窗口中
+;; 或者你可以使用 `C-xo' 使得光标跳到另一个窗口中
;; 你可以用 `progn'命令将s式结合起来:
(progn
@@ -216,7 +219,7 @@ filename: learn-emacs-lisp.el ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
-;; 我们将一些名字存到列表中；
+;; 我们将一些名字存到列表中：
(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
;; 用 `car'来取得第一个名字：
@@ -301,7 +304,8 @@ filename: learn-emacs-lisp.el (list 'face 'bold)))
(other-window 1))
-;; 这个函数使用了 `re-search-forward': 和查找一个字符串不同，你用这个命令可以查找一个模式，即正则表达式
+;; 这个函数使用了 `re-search-forward':
+;; 和查找一个字符串不同，你用这个命令可以查找一个模式，即正则表达式
;; 正则表达式 "Bonjour \\(.+\\)!" 的意思是:
;; 字符串 "Bonjour ", 之后跟着
diff --git a/zh-cn/elixir-cn.html.markdown b/zh-cn/elixir-cn.html.markdown new file mode 100644 index 00000000..daee8d3c --- /dev/null +++ b/zh-cn/elixir-cn.html.markdown @@ -0,0 +1,399 @@ +--- +language: elixir +contributors: + - ["Joao Marques", "http://github.com/mrshankly"] +translators: + - ["lidashuang", "http://github.com/lidashuang"] +filename: learnelixir-cn.ex +lang: zh-cn +--- + +Elixir 是一门构建在Erlang VM 之上的函数式编程语言。Elixir 完全兼容 Erlang, +另外还提供了更标准的语法，特性。 + +```elixir + +# 这是单行注释, 注释以井号开头 + +# 没有多行注释 +# 但你可以堆叠多个注释。 + +# elixir shell 使用命令 `iex` 进入。 +# 编译模块使用 `elixirc` 命令。 + +# 如果安装正确，这些命令都会在环境变量里 + +## --------------------------- +## -- 基本类型 +## --------------------------- + +# 数字 +3 # 整型 +0x1F # 整型 +3.0 # 浮点类型 + +# 原子(Atoms)，以 `:`开头 +:hello # atom + +# 元组(Tuple) 在内存中的存储是连续的 +{1,2,3} # tuple + +# 使用`elem`函数访问元组(tuple)里的元素: +elem({1, 2, 3}, 0) #=> 1 + +# 列表(list) +[1,2,3] # list + +# 可以用下面的方法访问列表的头尾元素: +[head | tail] = [1,2,3] +head #=> 1 +tail #=> [2,3] + +# 在elixir,就像在Erlang, `=` 表示模式匹配 (pattern matching) +# 不是赋值。 +# +# 这表示会用左边的模式(pattern)匹配右侧 +# +# 上面的例子中访问列表的头部和尾部就是这样工作的。 + +# 当左右两边不匹配时，会返回error, 在这个 +# 例子中，元组大小不一样。 +# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} + +# 还有二进制类型 (binaries) +<<1,2,3>> # binary + +# 字符串(Strings) 和 字符列表(char lists) +"hello" # string +'hello' # char list + +# 多行字符串 +""" +I'm a multi-line +string. +""" +#=> "I'm a multi-line\nstring.\n" + +# 所有的字符串(Strings)以UTF-8编码： +"héllò" #=> "héllò" + +# 字符串(Strings)本质就是二进制类型(binaries), 字符列表(char lists)本质是列表(lists) +<<?a, ?b, ?c>> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# 在 elixir中，`?a`返回 `a` 的 ASCII 整型值 +?a #=> 97 + +# 合并列表使用 `++`, 对于二进制类型则使用 `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'hello ' ++ 'world' #=> 'hello world' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"hello " <> "world" #=> "hello world" + +## --------------------------- +## -- 操作符(Operators) +## --------------------------- + +# 一些数学运算 +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# 在 elixir 中，操作符 `/` 返回值总是浮点数。 + +# 做整数除法使用 `div` +div(10, 2) #=> 5 + +# 为了得到余数使用 `rem` +rem(10, 3) #=> 1 + +# 还有 boolean 操作符: `or`, `and` and `not`. +# 第一个参数必须是boolean 类型 +true and true #=> true +false or true #=> true +# 1 and true #=> ** (ArgumentError) argument error + +# Elixir 也提供了 `||`, `&&` 和 `!` 可以接受任意的类型 +# 除了`false` 和 `nil` 其它都会被当作true. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil + +!true #=> false + +# 比较有: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` 和 `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` 和 `!==` 在比较整型和浮点类型时更为严格: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# 我们也可以比较两种不同的类型: +1 < :hello #=> true + +# 总的排序顺序定义如下: +# number < atom < reference < functions < port < pid < tuple < list < bit string + +# 引用Joe Armstrong ：“实际的顺序并不重要， +# 但是，一个整体排序是否经明确界定是非常重要的。” + +## --------------------------- +## -- 控制结构(Control Flow) +## --------------------------- + +# `if` 表达式 +if false do + "This will never be seen" +else + "This will" +end + +# 还有 `unless` +unless true do + "This will never be seen" +else + "This will" +end + +# 在Elixir中，很多控制结构都依赖于模式匹配 + +# `case` 允许我们把一个值与多种模式进行比较: +case {:one, :two} do + {:four, :five} -> + "This won't match" + {:one, x} -> + "This will match and assign `x` to `:two`" + _ -> + "This will match any value" +end + +# 模式匹配时，如果不需要某个值，通用的做法是把值 匹配到 `_` +# 例如，我们只需要要列表的头元素: +[head | _] = [1,2,3] +head #=> 1 + +# 下面的方式效果一样，但可读性更好 +[head | _tail] = [:a, :b, :c] +head #=> :a + +# `cond` 可以检测多种不同的分支 +# 使用 `cond` 代替多个`if` 表达式嵌套 +cond do + 1 + 1 == 3 -> + "I will never be seen" + 2 * 5 == 12 -> + "Me neither" + 1 + 2 == 3 -> + "But I will" +end + +# 经常可以看到最后一个条件等于'true'，这将总是匹配。 +cond do + 1 + 1 == 3 -> + "I will never be seen" + 2 * 5 == 12 -> + "Me neither" + true -> + "But I will (this is essentially an else)" +end + +# `try/catch` 用于捕获被抛出的值, 它也支持 `after` 子句， +# 无论是否值被捕获，after 子句都会被调用 +# `try/catch` +try do + throw(:hello) +catch + message -> "Got #{message}." +after + IO.puts("I'm the after clause.") +end +#=> I'm the after clause +# "Got :hello" + +## --------------------------- +## -- 模块和函数(Modules and Functions) +## --------------------------- + +# 匿名函数 (注意点) +square = fn(x) -> x * x end +square.(5) #=> 25 + + +# 也支持接收多个子句和卫士(guards). +# Guards 可以进行模式匹配 +# Guards 使用 `when` 关键字指明: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir 提供了很多内建函数 +# 在默认作用域都是可用的 +is_number(10) #=> true +is_list("hello") #=> false +elem({1,2,3}, 0) #=> 1 + +# 你可以在一个模块里定义多个函数，定义函数使用 `def` +defmodule Math do + def sum(a, b) do + a + b + end + + def square(x) do + x * x + end +end + +Math.sum(1, 2) #=> 3 +Math.square(3) #=> 9 + +# 保存到 `math.ex`，使用 `elixirc` 编译你的 Math 模块 +# 在终端里: elixirc math.ex + +# 在模块中可以使用`def`定义函数，使用 `defp` 定义私有函数 +# 使用`def` 定义的函数可以被其它模块调用 +# 私有函数只能在本模块内调用 +defmodule PrivateMath do + def sum(a, b) do + do_sum(a, b) + end + + defp do_sum(a, b) do + a + b + end +end + +PrivateMath.sum(1, 2) #=> 3 +# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError) + + +# 函数定义同样支持 guards 和 多重子句： +defmodule Geometry do + def area({:rectangle, w, h}) do + w * h + end + + def area({:circle, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometry.area({:rectangle, 2, 3}) #=> 6 +Geometry.area({:circle, 3}) #=> 28.25999999999999801048 +# Geometry.area({:circle, "not_a_number"}) +#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1 + +#由于不变性，递归是Elixir的重要组成部分 +defmodule Recursion do + def sum_list([head | tail], acc) do + sum_list(tail, acc + head) + end + + def sum_list([], acc) do + acc + end +end + +Recursion.sum_list([1,2,3], 0) #=> 6 + +# Elixir 模块支持属性，模块内建了一些属性，你也可以自定义属性 +defmodule MyMod do + @moduledoc """ + 内置的属性，模块文档 + """ + + @my_data 100 # 自定义属性 + IO.inspect(@my_data) #=> 100 +end + +## --------------------------- +## -- 记录和异常(Records and Exceptions) +## --------------------------- + +# 记录就是把特定值关联到某个名字的结构体 +defrecord Person, name: nil, age: 0, height: 0 + +joe_info = Person.new(name: "Joe", age: 30, height: 180) +#=> Person[name: "Joe", age: 30, height: 180] + +# 访问name的值 +joe_info.name #=> "Joe" + +# 更新age的值 +joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180] + +# 使用 `try` `rescue` 进行异常处理 +try do + raise "some error" +rescue + RuntimeError -> "rescued a runtime error" + _error -> "this will rescue any error" +end + +# 所有的异常都有一个message +try do + raise "some error" +rescue + x in [RuntimeError] -> + x.message +end + +## --------------------------- +## -- 并发(Concurrency) +## --------------------------- + +# Elixir 依赖于 actor并发模型。在Elixir编写并发程序的三要素： +# 创建进程，发送消息，接收消息 + +# 启动一个新的进程使用`spawn`函数，接收一个函数作为参数 + +f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> +spawn(f) #=> #PID<0.40.0> + + +# `spawn` 函数返回一个pid(进程标识符)，你可以使用pid向进程发送消息。 +# 使用 `<-` 操作符发送消息。 +# 我们需要在进程内接收消息，要用到 `receive` 机制。 + +defmodule Geometry do + def area_loop do + receive do + {:rectangle, w, h} -> + IO.puts("Area = #{w * h}") + area_loop() + {:circle, r} -> + IO.puts("Area = #{3.14 * r * r}") + area_loop() + end + end +end + +# 编译这个模块，在shell中创建一个进程，并执行 `area_looop` 函数。 +pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> + +# 发送一个消息给 `pid`， 会在receive语句进行模式匹配 +pid <- {:rectangle, 2, 3} +#=> Area = 6 +# {:rectangle,2,3} + +pid <- {:circle, 2} +#=> Area = 12.56000000000000049738 +# {:circle,2} + +# shell也是一个进程(process), 你可以使用`self`获取当前 pid +self() #=> #PID<0.27.0> +``` + +## 参考文献 + +* [Getting started guide](http://elixir-lang.org/getting_started/1.html) from [elixir webpage](http://elixir-lang.org) +* [Elixir Documentation](http://elixir-lang.org/docs/master/) +* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert +* "Programming Erlang: Software for a Concurrent World" by Joe Armstrong diff --git a/zh-cn/erlang-cn.html.markdown b/zh-cn/erlang-cn.html.markdown new file mode 100644 index 00000000..32e84278 --- /dev/null +++ b/zh-cn/erlang-cn.html.markdown @@ -0,0 +1,259 @@ +--- +language: erlang +lang: zh-cn +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] +translators: + - ["Jakukyo Friel", "http://weakish.github.io"] +filename: erlang-cn.erl +--- + +```erlang +% 百分比符号标明注释的开始。 + +%% 两个符号通常用于注释函数。 + +%%% 三个符号通常用于注释模块。 + +% Erlang 里使用三种标点符号： +% 逗号 (`,`) 分隔函数调用中的参数、数据构建和模式。 +% 句号 (`.`) （后跟空格）分隔函数和 shell 中的表达式。 +% 分号 (`;`) 分隔语句。以下环境中使用语句： +% 函数定义和`case`、`if`、`try..catch`、`receive`表达式。 + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. 变量和模式匹配 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Num = 42. % 变量必须以大写字母开头。 + +% Erlang 的变量只能赋值一次。如果给变量赋不同的值，会导致错误： +Num = 43. % ** exception error: no match of right hand side value 43 + +% 大多数语言中`=`表示赋值语句，在Erlang中，则表示模式匹配。 +% `Lhs = Rhs`实际上意味着： +% 演算右边(Rhs), 将结果与左边的模式匹配。 +Num = 7 * 6. + +% 浮点数 +Pi = 3.14159. + +% Atoms 用于表示非数字的常量。 +% Atom 以小写字母开始，包含字母、数字、`_`和`@`。 +Hello = hello. +OtherNode = example@node. + +% Atom 中如果包含特殊字符，可以用单引号括起。 +AtomWithSpace = 'some atom with space'. + +% Erlang 的元组类似 C 的 struct. +Point = {point, 10, 45}. + +% 使用模式匹配操作符`=`获取元组的值。 +{point, X, Y} = Point. % X = 10, Y = 45 + +% 我们可以使用`_`存放我们不感兴趣的变量。 +% `_`被称为匿名变量。和其他变量不同， +% 同一个模式中的多个`_`变量不必绑定到相同的值。 +Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. +{_, {_, {_, Who}, _}, _} = Person. % Who = joe + +% 列表使用方括号，元素间使用逗号分隔。 +% 列表的元素可以是任意类型。 +% 列表的第一个元素称为列表的 head，其余元素称为列表的 tail。 +ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. + +% 若`T`是一个列表，那么`[H|T]`同样是一个列表，head为`H`，tail为`T`. +% `|`分隔列表的 head 和 tail. +% `[]`是空列表。 +% 我们可以使用模式匹配操作来抽取列表中的元素。 +% 如果我们有一个非空的列表`L`，那么`[X|Y] = L`则 +% 抽取 L 的 head 至 X，tail 至 Y （X、Y需为未定义的变量）。 +[FirstThing|OtherThingsToBuy] = ThingsToBuy. +% FirstThing = {apples, 10} +% OtherThingsToBuy = {pears, 6}, {milk, 3} + +% Erlang 中的字符串其实是由整数组成的数组。字符串使用双引号。 +Name = "Hello". +[72, 101, 108, 108, 111] = "Hello". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. 循序编程 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Module 是 Erlang 代码的基本单位。我们编写的所有函数都储存在 module 中。 +% Module 存储在后缀为 `.erl` 的文件中。 +% Module 必须事先编译。编译好的 module 以 `.beam` 结尾。 +-module(geometry). +-export([area/1]). % module 对外暴露的函数列表 + +% `area`函数包含两个分句，分句间以分号相隔。 +% 最后一个分句以句号加换行结尾。 +% 每个分句由头、体两部门组成。 +% 头部包含函数名称和用括号括起的模式， +% 体部包含一系列表达式，如果头部的模式和调用时的参数匹配，这些表达式会被演算。 +% 模式匹配依照定义时的顺序依次进行。 +area({rectangle, Width, Ht}) -> Width * Ht; +area({circle, R}) -> 3.14159 * R * R. + +% 编译文件为 geometry.erl. +c(geometry). % {ok,geometry} + +% 调用函数时必须使用 module 名和函数名。 +geometry:area({rectangle, 10, 5}). % 50 +geometry:area({circle, 1.4}). % 6.15752 + +% 在 Erlang 中，同一模块中，参数数目不同，名字相同的函数是完全不同的函数。 +-module(lib_misc). +-export([sum/1]). % 对外暴露的`sum`函数接受一个参数：由整数组成的列表。 +sum(L) -> sum(L, 0). +sum([], N) -> N; +sum([H|T], N) -> sum(T, H+N). + +% fun 是匿名函数。它们没有名字，不过可以赋值给变量。 +Double = fun(X) -> 2*X end. % `Double` 指向匿名函数 #Fun<erl_eval.6.17052888> +Double(2). % 4 + +% fun 可以作为函数的参数和返回值。 +Mult = fun(Times) -> ( fun(X) -> X * Times end ) end. +Triple = Mult(3). +Triple(5). % 15 + +% 列表解析是创建列表的表达式（不使用fun、map 或 filter）。 +% `[F(X) || X <- L]` 表示 "由 `F(X)` 组成的列表，其中 `X` 取自列表 `L`。 +L = [1,2,3,4,5]. +[2*X || X <- L]. % [2,4,6,8,10] +% 列表解析可以使用生成器，也可以使用过滤器，过滤器用于筛选列表的一部分。 +EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% Guard 是用于增强模式匹配的结构。 +% Guard 可用于简单的测试和比较。 +% Guard 可用于函数定义的头部，以`when`关键字开头，或者其他可以使用表达式的地方。 +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% guard 可以由一系列 guard 表达式组成，这些表达式以逗号分隔。 +% `GuardExpr1, GuardExpr2, ..., GuardExprN` 为真，当且仅当每个 guard 表达式均为真。 +is_cat(A) when is_atom(A), A =:= cat -> true; +is_cat(A) -> false. +is_dog(A) when is_atom(A), A =:= dog -> true; +is_dog(A) -> false. + +% guard 序列 `G1; G2; ...; Gn` 为真，当且仅当其中任意一个 guard 表达式为真。 +is_pet(A) when is_dog(A); is_cat(A) -> true; +is_pet(A) -> false. + +% Record 可以将元组中的元素绑定到特定的名称。 +% Record 定义可以包含在 Erlang 源代码中，也可以放在后缀为`.hrl`的文件中（Erlang 源代码中 include 这些文件）。 +-record(todo, { + status = reminder, % Default value + who = joe, + text +}). + +% 在定义某个 record 之前，我们需要在 shell 中导入 record 的定义。 +% 我们可以使用 shell 函数`rr` (read records 的简称）。 +rr("records.hrl"). % [todo] + +% 创建和更新 record。 +X = #todo{}. +% #todo{status = reminder, who = joe, text = undefined} +X1 = #todo{status = urgent, text = "Fix errata in book"}. +% #todo{status = urgent, who = joe, text = "Fix errata in book"} +X2 = X1#todo{status = done}. +% #todo{status = done,who = joe,text = "Fix errata in book"} + +% `case` 表达式。 +% `filter` 返回由列表`L`中所有满足`P(x)`为真的元素`X`组成的列表。 +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% `if` 表达式。 +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil; + end. + +% 警告: `if` 表达式里至少有一个 guard 为真，否则会触发异常。 + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. 异常 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% 当遇到内部错误或显式调用时，会触发异常。 +% 显式调用包括 `throw(Exception)`, `exit(Exception)` 和 +% `erlang:error(Exception)`. +generate_exception(1) -> a; +generate_exception(2) -> throw(a); +generate_exception(3) -> exit(a); +generate_exception(4) -> {'EXIT', a}; +generate_exception(5) -> erlang:error(a). + +% Erlang 有两种捕获异常的方法。其一是将调用包裹在`try...catch`表达式中。 +catcher(N) -> + try generate_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% 另一种方式是将调用包裹在`catch`表达式中。 +% 此时异常会被转化为一个描述错误的元组。 +catcher(N) -> catch generate_exception(N). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 4. 并发 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Erlang 依赖于 actor并发模型。在 Erlang 编写并发程序的三要素： +% 创建进程，发送消息，接收消息 + +% 启动一个新的进程使用`spawn`函数，接收一个函数作为参数 + +F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768> +spawn(F). % <0.44.0> + +% `spawn` 函数返回一个pid(进程标识符)，你可以使用pid向进程发送消息。 +% 使用 `!` 操作符发送消息。 +% 我们需要在进程内接收消息，要用到 `receive` 机制。 + +-module(caculateGeometry). +-compile(export_all). +caculateAera() -> + receive + {rectangle, W, H} -> + W * H; + {circle, R} -> + 3.14 * R * R; + _ -> + io:format("We can only caculate area of rectangles or circles.") + end. + +% 编译这个模块，在 shell 中创建一个进程，并执行 `caculateArea` 函数。 +c(caculateGeometry). +CaculateAera = spawn(caculateGeometry, caculateAera, []). +CaculateAera ! {circle, 2}. % 12.56000000000000049738 + +% shell也是一个进程(process), 你可以使用`self`获取当前 pid + +self(). % <0.41.0> + +``` + +## References + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) diff --git a/zh-cn/git-cn.html.markdown b/zh-cn/git-cn.html.markdown new file mode 100644 index 00000000..4ef3ffb8 --- /dev/null +++ b/zh-cn/git-cn.html.markdown @@ -0,0 +1,374 @@ +--- +category: tool +tool: git +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["Chenbo Li", "http://binarythink.net"] +lang: zh-cn +--- + +Git是一个分布式版本控制及源代码管理工具 + +Git可以为你的项目保存若干快照，以此来对整个项目进行版本管理 + +## 版本 + +### 什么是版本控制 + +版本控制系统就是根据时间来记录一个或多个文件的更改情况的系统。 + +### 集中式版本控制 VS 分布式版本控制 + +* 集中式版本控制的主要功能为同步，跟踪以及备份文件 +* 分布式版本控制则更注重共享更改。每一次更改都有唯一的标识 +* 分布式系统没有预定的结构。你也可以用git很轻松的实现SVN风格的集中式系统控制 + +[更多信息](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### 为什么要使用Git + +* 可以离线工作 +* 和他人协同工作变得简单 +* 分支很轻松 +* 合并很容易 +* Git系统速度快，也很灵活 + +## Git 架构 + + +### 版本库 + +一系列文件，目录，历史记录，提交记录和头指针。 +可以把它视作每个源代码文件都带有历史记录属性数据结构 + +一个Git版本库包括一个 .git 目录和其工作目录 + +### .git 目录(版本库的一部分) + +.git 目录包含所有的配置、日志、分支信息、头指针等 +[详细列表](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### 工作目录 (版本库的一部分) + +版本库中的目录和文件，可以看做就是你工作时的目录 + +### 索引(.git 目录) + +索引就是git中的 staging 区. 可以算作是把你的工作目录与Git版本库分割开的一层 +这使得开发者能够更灵活的决定要将要在版本库中添加什么内容 + +### 提交 + +一个 git 提交就是一组更改或者对工作目录操作的快照 +比如你添加了5个文件，删除了2个文件，那么这些变化就会被写入一个提交比如你添加了5个文件，删除了2个文件，那么这些变化就会被写入一个提交中 +而这个提交之后也可以被决定是否推送到另一个版本库中 + +### 分支 + +分支其实就是一个指向你最后一次的提交的指针 +当你提交时，这个指针就会自动指向最新的提交 + +### 头指针 与 头(.git 文件夹的作用) + +头指针是一个指向当前分支的指针，一个版本库只有一个当前活动的头指针 +而头则可以指向版本库中任意一个提交，每个版本库也可以有多个头 + +### 其他形象化解释 + +* [给计算机科学家的解释](http://eagain.net/articles/git-for-computer-scientists/) +* [给设计师的解释](http://hoth.entp.com/output/git_for_designers.html) + + +## 命令 + + +### 初始化 + +创建一个新的git版本库。这个版本库的配置、存储等信息会被保存到.git文件夹中 + +```bash +$ git init +``` + +### 配置 + +更改设置。可以是版本库的设置，也可以是系统的或全局的 + + +```bash +# 输出、设置基本的全局变量 +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[关于git的更多设置](http://git-scm.com/docs/git-config) + +### 帮助 + +git内置了对命令非常详细的解释，可以供我们快速查阅 + +```bash +# 查找可用命令 +$ git help + +# 查找所有可用命令 +$ git help -a + +# 在文档当中查找特定的命令 +# git help <命令> +$ git help add +$ git help commit +$ git help init +``` + +### 状态 + +显示索引文件（也就是当前工作空间）和当前的头指针指向的提交的不同 + + +```bash +# 显示分支，为跟踪文件，更改和其他不同 +$ git status + +# 查看其他的git status的用法 +$ git help status +``` + +### 添加 + +添加文件到当前工作空间中。如果你不使用 `git add` 将文件添加进去， +那么这些文件也不会添加到之后的提交之中 + +```bash +# 添加一个文件 +$ git add HelloWorld.java + +# 添加一个子目录中的文件 +$ git add /path/to/file/HelloWorld.c + +# 支持正则表达式 +$ git add ./*.java +``` + +### 分支 + +管理分支，可以通过下列命令对分支进行增删改查 + +```bash +# 查看所有的分支和远程分支 +$ git branch -a + +# 创建一个新的分支 +$ git branch myNewBranch + +# 删除一个分支 +$ git branch -d myBranch + +# 重命名分支 +# git branch -m <旧名称> <新名称> +$ git branch -m myBranchName myNewBranchName + +# 编辑分支的介绍 +$ git branch myBranchName --edit-description +``` + +### 检出 + +将当前工作空间更新到索引所标识的或者某一特定的工作空间 + +```bash +# 检出一个版本库，默认将更新到master分支 +$ git checkout +# 检出到一个特定的分支 +$ git checkout branchName +# 新建一个分支，并且切换过去，相当于"git branch <名字>; git checkout <名字>" +$ git checkout -b newBranch +``` + +### clone + +这个命令就是将一个版本库拷贝到另一个目录中，同时也将 +分支都拷贝到新的版本库中。这样就可以在新的版本库中提交到远程分支 + +```bash +# clone learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git +``` + +### commit + +将当前索引的更改保存为一个新的提交，这个提交包括用户做出的更改与信息 + +```bash +# 提交时附带提交信息 +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +``` + +### diff + +显示当前工作空间和提交的不同 + +```bash +# 显示工作目录和索引的不同 +$ git diff + +# 显示索引和最近一次提交的不同 +$ git diff --cached + +# 显示工作目录和最近一次提交的不同 +$ git diff HEAD +``` + +### grep + +可以在版本库中快速查找 + +可选配置： + +```bash +# 感谢Travis Jeffery提供的以下用法： +# 在搜索结果中显示行号 +$ git config --global grep.lineNumber true + +# 是搜索结果可读性更好 +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# 在所有的java中查找variableName +$ git grep 'variableName' -- '*.java' + +# 搜索包含 "arrayListName" 和, "add" 或 "remove" 的所有行 +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +更多的例子可以查看： +[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +显示这个版本库的所有提交 + +```bash +# 显示所有提交 +$ git log + +# 显示某几条提交信息 +$ git log -n 10 + +# 仅显示合并提交 +$ git log --merges +``` + +### merge + +合并就是将外部的提交合并到自己的分支中 + +```bash +# 将其他分支合并到当前分支 +$ git merge branchName + +# 在合并时创建一个新的合并后的提交 +$ git merge --no-ff branchName +``` + +### mv + +重命名或移动一个文件 + +```bash +# 重命名 +$ git mv HelloWorld.c HelloNewWorld.c + +# 移动 +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# 强制重命名或移动 +# 这个文件已经存在，将要覆盖掉 +$ git mv -f myFile existingFile +``` + +### pull + +从远端版本库合并到当前分支 + +```bash +# 从远端origin的master分支更新版本库 +# git pull <远端> <分支> +$ git pull origin master +``` + +### push + +把远端的版本库更新 + +```bash +# 把本地的分支更新到远端origin的master分支上 +# git push <远端> <分支> +# git push 相当于 git push origin master +$ git push origin master +``` + +### rebase (谨慎使用) + +将一个分支上所有的提交历史都应用到另一个分支上 +*不要在一个已经公开的远端分支上使用rebase*. + +```bash +# 将experimentBranch应用到master上面 +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[更多阅读](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (谨慎使用) + +将当前的头指针复位到一个特定的状态。这样可以使你撤销merge、pull、commits、add等 +这是个很强大的命令，但是在使用时一定要清楚其所产生的后果 + +```bash +# 使 staging 区域恢复到上次提交时的状态，不改变现在的工作目录 +$ git reset + +# 使 staging 区域恢复到上次提交时的状态，覆盖现在的工作目录 +$ git reset --hard + +# 将当前分支恢复到某次提交，不改变现在的工作目录 +# 在工作目录中所有的改变仍然存在 +$ git reset 31f2bb1 + +# 将当前分支恢复到某次提交，覆盖现在的工作目录 +# 并且删除所有未提交的改变和指定提交之后的所有提交 +$ git reset --hard 31f2bb1 +``` + +### rm + +和add相反，从工作空间中去掉某个文件 + +```bash +# 移除 HelloWorld.c +$ git rm HelloWorld.c + +# 移除子目录中的文件 +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## 更多阅读 + +* [tryGit - 学习Git的有趣方式](http://try.github.io/levels/1/challenges/1) + +* [git-scm - 视频教程](http://git-scm.com/videos) + +* [git-scm - 文档](http://git-scm.com/docs) + +* [Atlassian Git - 教程与工作流程](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown new file mode 100644 index 00000000..49224085 --- /dev/null +++ b/zh-cn/go-cn.html.markdown @@ -0,0 +1,286 @@ +--- +language: Go +lang: zh-cn +filename: learngo-cn.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["pantaovay", "https://github.com/pantaovay"] + - ["lidashuang", "https://github.com/lidashuang"] + +--- + +发明Go语言是出于更好地完成工作的需要。Go不是计算机科学的最新发展潮流，但它却提供了解决现实问题的最新最快的方法。 + +Go拥有命令式语言的静态类型，编译很快，执行也很快，同时加入了对于目前多核CPU的并发计算支持，也有相应的特性来实现大规模编程。 + +Go语言有非常棒的标准库，还有一个充满热情的社区。 + +```go +// 单行注释 +/* 多行 + 注释 */ + +// 导入包的子句在每个源文件的开头。 +// Main比较特殊，它用来声明可执行文件，而不是一个库。 +package main + +// Import语句声明了当前文件引用的包。 +import ( + "fmt" // Go语言标准库中的包 + "net/http" // 一个web服务器包 + "strconv" // 字符串转换 +) + +// 函数声明：Main是程序执行的入口。 +// 不管你喜欢还是不喜欢，反正Go就用了花括号来包住函数体。 +func main() { + // 往标准输出打印一行。 + // 用包名fmt限制打印函数。 + fmt.Println("Hello world!") + + // 调用当前包的另一个函数。 + beyondHello() +} + +// 函数可以在括号里加参数。 +// 如果没有参数的话，也需要一个空括号。 +func beyondHello() { + var x int // 变量声明，变量必须在使用之前声明。 + x = 3 // 变量赋值。 + // 可以用:=来偷懒，它自动把变量类型、声明和赋值都搞定了。 + y := 4 + sum, prod := learnMultiple(x, y) // 返回多个变量的函数 + fmt.Println("sum:", sum, "prod:", prod) // 简单输出 + learnTypes() // 少于y分钟，学的更多！ +} + +// 多变量和多返回值的函数 +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // 返回两个值 +} + +// 内置变量类型和关键词 +func learnTypes() { + // 短声明给你所想。 + s := "Learn Go!" // String类型 + + s2 := `A "raw" string literal +can include line breaks.` // 同样是String类型 + + // 非ascii字符。Go使用UTF-8编码。 + g := 'Σ' // rune类型，int32的别名，使用UTF-8编码 + + f := 3.14195 // float64类型，IEEE-754 64位浮点数 + c := 3 + 4i // complex128类型，内部使用两个float64表示 + + // Var变量可以直接初始化。 + var u uint = 7 // unsigned 无符号变量，但是实现依赖int型变量的长度 + var pi float32 = 22. / 7 + + // 字符转换 + n := byte('\n') // byte是uint8的别名 + + // 数组类型编译的时候大小固定。 + var a4 [4] int // 有4个int变量的数组，初始为0 + a3 := [...]int{3, 1, 5} // 有3个int变量的数组，同时进行了初始化 + + // Slice 可以动态的增删。Array和Slice各有千秋，但是使用slice的地方更多些。 + s3 := []int{4, 5, 9} // 和a3相比，这里没有省略号 + s4 := make([]int, 4) // 分配一个有4个int型变量的slice，全部被初始化为0 + + var d2 [][]float64 // 声明而已，什么都没有分配 + bs := []byte("a slice") // 类型转换的语法 + + p, q := learnMemory() // 声明p,q为int型变量的指针 + fmt.Println(*p, *q) // * 取值 + + // Map是动态可增长关联数组，和其他语言中的hash或者字典相似。 + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + // 在Go语言中未使用的变量在编译的时候会报错，而不是warning。 + // 下划线 _ 可以使你“使用”一个变量，但是丢弃它的值。 + _,_,_,_,_,_,_,_,_ = s2, g, f, u, pi, n, a3, s4, bs + // 输出变量 + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // 回到流程控制 +} + +// Go全面支持垃圾回收。Go有指针，但是不支持指针运算。 +// 你会因为空指针而犯错，但是不会因为增加指针而犯错。 +func learnMemory() (p, q *int) { + // 返回int型变量指针p和q + p = new(int) // 内置函数new分配内存 + // 自动将分配的int赋值0，p不再是空的了。 + s := make([]int, 20) // 给20个int变量分配一块内存 + s[3] = 7 // 赋值 + r := -2 // 声明另一个局部变量 + return &s[3], &r // & 取地址 +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // If需要花括号，括号就免了 + if true { + fmt.Println("told ya") + } + // 用go fmt 命令可以帮你格式化代码，所以不用怕被人吐槽代码风格了， + // 也不用容忍被人的代码风格。 + if false { + // pout + } else { + // gloat + } + // 如果太多嵌套的if语句，推荐使用switch + x := 1 + switch x { + case 0: + case 1: + // 隐式调用break语句，匹配上一个即停止 + case 2: + // 不会运行 + } + // 和if一样，for也不用括号 + for x := 0; x < 3; x++ { // ++ 自增 + fmt.Println("iteration", x) + } + // x在这里还是1。为什么？ + + // for 是go里唯一的循环关键字，不过它有很多变种 + for { // 死循环 + break // 骗你的 + continue // 不会运行的 + } + // 和for一样，if中的:=先给y赋值，然后再和x作比较。 + if y := expensiveComputation(); y > x { + x = y + } + // 闭包函数 + xBig := func() bool { + return x > 100 // x是上面声明的变量引用 + } + fmt.Println("xBig:", xBig()) // true （上面把y赋给x了） + x /= 1e5 // x变成10 + fmt.Println("xBig:", xBig()) // 现在是false + + // 当你需要goto的时候，你会爱死它的！ + goto love +love: + + learnInterfaces() // 好东西来了！ +} + +// 定义Stringer为一个接口类型，有一个方法String +type Stringer interface { + String() string +} + +// 定义pair为一个结构体，有x和y两个int型变量。 +type pair struct { + x, y int +} + +// 定义pair类型的方法，实现Stringer接口。 +func (p pair) String() string { // p被叫做“接收器” + // Sprintf是fmt包中的另一个公有函数。 + // 用 . 调用p中的元素。 + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // 花括号用来定义结构体变量，:=在这里将一个结构体变量赋值给p。 + p := pair{3, 4} + fmt.Println(p.String()) // 调用pair类型p的String方法 + var i Stringer // 声明i为Stringer接口类型 + i = p // 有效！因为p实现了Stringer接口（类似java中的塑型） + // 调用i的String方法，输出和上面一样 + fmt.Println(i.String()) + + // fmt包中的Println函数向对象要它们的string输出，实现了String方法就可以这样使用了。 + // （类似java中的序列化） + fmt.Println(p) // 输出和上面一样，自动调用String函数。 + fmt.Println(i) // 输出和上面一样。 + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok"用来判断有没有正常工作 + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // ok 为false，因为m中没有1 + fmt.Println("no one there") + } else { + fmt.Print(x) // 如果x在map中的话，x就是那个值喽。 + } + // 错误可不只是ok，它还可以给出关于问题的更多细节。 + if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value + // 输出"strconv.ParseInt: parsing "non-int": invalid syntax" + fmt.Println(err) + } + // 待会再说接口吧。同时， + learnConcurrency() +} + +// c是channel类型，一个并发安全的通信对象。 +func inc(i int, c chan int) { + c <- i + 1 // <-把右边的发送到左边的channel。 +} + +// 我们将用inc函数来并发地增加一些数字。 +func learnConcurrency() { + // 用make来声明一个slice，make会分配和初始化slice，map和channel。 + c := make(chan int) + // 用go关键字开始三个并发的goroutine，如果机器支持的话，还可能是并行执行。 + // 三个都被发送到同一个channel。 + go inc(0, c) // go is a statement that starts a new goroutine. + go inc(10, c) + go inc(-805, c) + // 从channel中读取结果并打印。 + // 打印出什么东西是不可预知的。 + fmt.Println(<-c, <-c, <-c) // channel在右边的时候，<-是读操作。 + + cs := make(chan string) // 操作string的channel + cc := make(chan chan string) // 操作channel的channel + go func() { c <- 84 }() // 开始一个goroutine来发送一个新的数字 + go func() { cs <- "wordy" }() // 发送给cs + // Select类似于switch，但是每个case包括一个channel操作。 + // 它随机选择一个准备好通讯的case。 + select { + case i := <-c: // 从channel接收的值可以赋给其他变量 + fmt.Println("it's a", i) + case <-cs: // 或者直接丢弃 + fmt.Println("it's a string") + case <-cc: // 空的，还没作好通讯的准备 + fmt.Println("didn't happen.") + } + // 上面c或者cs的值被取到，其中一个goroutine结束，另外一个一直阻塞。 + + learnWebProgramming() // Go很适合web编程，我知道你也想学！ +} + +// http包中的一个简单的函数就可以开启web服务器。 +func learnWebProgramming() { + // ListenAndServe第一个参数指定了监听端口，第二个参数是一个接口，特定是http.Handler。 + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // 不要无视错误。 +} + +// 使pair实现http.Handler接口的ServeHTTP方法。 +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // 使用http.ResponseWriter返回数据 + w.Write([]byte("You learned Go in Y minutes!")) +} +``` + +## 更进一步 + +Go的根源在[Go官方网站](http://golang.org/)。 +在那里你可以学习入门教程，通过浏览器交互式地学习，而且可以读到很多东西。 + +强烈推荐阅读语言定义部分，很简单而且很简洁！(as language definitions go these days.) + +学习Go还要阅读Go[标准库的源代码](http://golang.org/src/)，全部文档化了，可读性非常好，可以学到go，go style和go idioms。在[文档](http://golang.org/pkg/)中点击函数名，源代码就出来了！ diff --git a/zh-cn/groovy-cn.html.markdown b/zh-cn/groovy-cn.html.markdown new file mode 100644 index 00000000..562a0284 --- /dev/null +++ b/zh-cn/groovy-cn.html.markdown @@ -0,0 +1,420 @@ +--- +language: Groovy +filename: learngroovy-cn.groovy +contributors: + - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"] +translators: + - ["Todd Gao", "http://github.com/7c00"] +lang: zh-cn +--- + +Groovy - Java平台的动态语言。[了解更多。](http://www.groovy-lang.org/) + +```groovy + +/* + 安装： + + 1) 安装 GVM - http://gvmtool.net/ + 2) 安装 Groovy： gvm install groovy + 3) 启动 groovy 控制台，键入： groovyConsole + +*/ + +// 双斜线开始的是单行注释 +/* +像这样的是多行注释 +*/ + +// Hello World +println "Hello world!" + +/* + 变量： + + 可以给变量赋值，以便稍后使用 +*/ + +def x = 1 +println x + +x = new java.util.Date() +println x + +x = -3.1499392 +println x + +x = false +println x + +x = "Groovy!" +println x + +/* + 集合和映射 +*/ + +//创建一个空的列表 +def technologies = [] + +/*** 往列表中增加一个元素 ***/ + +// 和Java一样 +technologies.add("Grails") + +// 左移添加，返回该列表 +technologies << "Groovy" + +// 增加多个元素 +technologies.addAll(["Gradle","Griffon"]) + +/*** 从列表中删除元素 ***/ + +// 和Java一样 +technologies.remove("Griffon") + +// 减号也行 +technologies = technologies - 'Grails' + +/*** 遍历列表 ***/ + +// 遍历列表中的元素 +technologies.each { println "Technology: $it"} +technologies.eachWithIndex { it, i -> println "$i: $it"} + +/*** 检查列表内容 ***/ + +//判断列表是否包含某元素，返回boolean +contained = technologies.contains( 'Groovy' ) + +// 或 +contained = 'Groovy' in technologies + +// 检查多个元素 +technologies.containsAll(['Groovy','Grails']) + +/*** 列表排序 ***/ + +// 排序列表（修改原列表） +technologies.sort() + +// 要想不修改原列表，可以这样： +sortedTechnologies = technologies.sort( false ) + +/*** 列表操作 ***/ + +//替换列表元素 +Collections.replaceAll(technologies, 'Gradle', 'gradle') + +//打乱列表 +Collections.shuffle(technologies, new Random()) + +//清空列表 +technologies.clear() + +//创建空的映射 +def devMap = [:] + +//增加值 +devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] +devMap.put('lastName','Perez') + +//遍历映射元素 +devMap.each { println "$it.key: $it.value" } +devMap.eachWithIndex { it, i -> println "$i: $it"} + +//判断映射是否包含某键 +assert devMap.containsKey('name') + +//判断映射是否包含某值 +assert devMap.containsValue('Roberto') + +//取得映射所有的键 +println devMap.keySet() + +//取得映射所有的值 +println devMap.values() + +/* + Groovy Beans + + GroovyBeans 是 JavaBeans，但使用了更简单的语法 + + Groovy 被编译为字节码时，遵循下列规则。 + + * 如果一个名字声明时带有访问修饰符（public, private, 或者 protected）， + 则会生成一个字段（field）。 + + * 名字声明时没有访问修饰符，则会生成一个带有public getter和setter的 + private字段，即属性（property）。 + + * 如果一个属性声明为final，则会创建一个final的private字段，但不会生成setter。 + + * 可以声明一个属性的同时定义自己的getter和setter。 + + * 可以声明具有相同名字的属性和字段，该属性会使用该字段。 + + * 如果要定义private或protected属性，必须提供声明为private或protected的getter + 和setter。 + + * 如果使用显式或隐式的 this（例如 this.foo, 或者 foo）访问类的在编译时定义的属性， + Groovy会直接访问对应字段，而不是使用getter或者setter + + * 如果使用显式或隐式的 foo 访问一个不存在的属性，Groovy会通过元类（meta class） + 访问它，这可能导致运行时错误。 + +*/ + +class Foo { + // 只读属性 + final String name = "Roberto" + + // 只读属性，有public getter和protected setter + String language + protected void setLanguage(String language) { this.language = language } + + // 动态类型属性 + def lastName +} + +/* + 逻辑分支和循环 +*/ + +//Groovy支持常见的if - else语法 +def x = 3 + +if(x==1) { + println "One" +} else if(x==2) { + println "Two" +} else { + println "X greater than Two" +} + +//Groovy也支持三元运算符 +def y = 10 +def x = (y > 1) ? "worked" : "failed" +assert x == "worked" + +//for循环 +//使用区间（range）遍历 +def x = 0 +for (i in 0 .. 30) { + x += i +} + +//遍历列表 +x = 0 +for( i in [5,3,2,1] ) { + x += i +} + +//遍历数组 +array = (0..20).toArray() +x = 0 +for (i in array) { + x += i +} + +//遍历映射 +def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] +x = 0 +for ( e in map ) { + x += e.value +} + +/* + 运算符 + + 在Groovy中以下常用运算符支持重载： + http://www.groovy-lang.org/operators.html#Operator-Overloading + + 实用的groovy运算符 +*/ +//展开（spread）运算符：对聚合对象的所有元素施加操作 +def technologies = ['Groovy','Grails','Gradle'] +technologies*.toUpperCase() // 相当于 technologies.collect { it?.toUpperCase() } + +//安全导航（safe navigation）运算符：用来避免NullPointerException +def user = User.get(1) +def username = user?.username + + +/* + 闭包 + Groovy闭包好比代码块或者方法指针，它是一段代码定义，可以以后执行。 + + 更多信息见：http://www.groovy-lang.org/closures.html +*/ +//例子： +def clos = { println "Hello World!" } + +println "Executing the Closure:" +clos() + +//传参数给闭包 +def sum = { a, b -> println a+b } +sum(2,4) + +//闭包可以引用参数列表以外的变量 +def x = 5 +def multiplyBy = { num -> num * x } +println multiplyBy(10) + +// 只有一个参数的闭包可以省略参数的定义 +def clos = { print it } +clos( "hi" ) + +/* + Groovy可以记忆闭包结果 [1][2][3] +*/ +def cl = {a, b -> + sleep(3000) // 模拟费时操作 + a + b +} + +mem = cl.memoize() + +def callClosure(a, b) { + def start = System.currentTimeMillis() + mem(a, b) + println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs." +} + +callClosure(1, 2) +callClosure(1, 2) +callClosure(2, 3) +callClosure(2, 3) +callClosure(3, 4) +callClosure(3, 4) +callClosure(1, 2) +callClosure(2, 3) +callClosure(3, 4) + +/* + Expando + + Expando类是一种动态bean类，可以给它的实例添加属性和添加闭包作为方法 + + http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html +*/ + def user = new Expando(name:"Roberto") + assert 'Roberto' == user.name + + user.lastName = 'Pérez' + assert 'Pérez' == user.lastName + + user.showInfo = { out -> + out << "Name: $name" + out << ", Last name: $lastName" + } + + def sw = new StringWriter() + println user.showInfo(sw) + + +/* + 元编程(MOP) +*/ + +//使用ExpandoMetaClass增加行为 +String.metaClass.testAdd = { + println "we added this" +} + +String x = "test" +x?.testAdd() + +//拦截方法调用 +class Test implements GroovyInterceptable { + def sum(Integer x, Integer y) { x + y } + + def invokeMethod(String name, args) { + System.out.println "Invoke method $name with args: $args" + } +} + +def test = new Test() +test?.sum(2,3) +test?.multiply(2,3) + +//Groovy支持propertyMissing，来处理属性解析尝试 +class Foo { + def propertyMissing(String name) { name } +} +def f = new Foo() + +assertEquals "boo", f.boo + +/* + 类型检查和静态编译 + Groovy天生是并将永远是一门动态语言，但也支持类型检查和静态编译 + + 更多： http://www.infoq.com/articles/new-groovy-20 +*/ +//类型检查 +import groovy.transform.TypeChecked + +void testMethod() {} + +@TypeChecked +void test() { + testMeethod() + + def name = "Roberto" + + println naameee + +} + +//另一例子 +import groovy.transform.TypeChecked + +@TypeChecked +Integer test() { + Integer num = "1" + + Integer[] numbers = [1,2,3,4] + + Date date = numbers[1] + + return "Test" + +} + +//静态编译例子 +import groovy.transform.CompileStatic + +@CompileStatic +int sum(int x, int y) { + x + y +} + +assert sum(2,5) == 7 + + +``` + +## 进阶资源 + +[Groovy文档](http://www.groovy-lang.org/documentation.html) + +[Groovy web console](http://groovyconsole.appspot.com/) + +加入[Groovy用户组](http://www.groovy-lang.org/usergroups.html) + +## 图书 + +* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook) + +* [Groovy in Action] (http://manning.com/koenig2/) + +* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do) + +[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/zh-cn/haskell-cn.html.markdown b/zh-cn/haskell-cn.html.markdown new file mode 100644 index 00000000..8904970f --- /dev/null +++ b/zh-cn/haskell-cn.html.markdown @@ -0,0 +1,400 @@ +--- +language: Haskell +filename: learn-haskell-zh.hs +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Peiyong Lin", ""] + - ["chad luo", "http://yuki.rocks"] +lang: zh-cn +--- + +Haskell 是一门实用的函数式编程语言，因其 Monads 与类型系统而闻名。而我使用它则是因为它异常优雅。用 Haskell 编程令我感到非常快乐。 + +```haskell +-- 单行注释以两个减号开头 +{- 多行注释像这样 + 被一个闭合的块包围 +-} + +---------------------------------------------------- +-- 1. 简单的数据类型和操作符 +---------------------------------------------------- + +-- 数字 +3 -- 3 +-- 数学计算 +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- 默认除法不是整除 +35 / 4 -- 8.75 + +-- 整除 +35 `div` 4 -- 8 + +-- 布尔值 +True +False + +-- 布尔操作 +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- 在上面的例子中，`not` 是一个接受一个参数的函数。 +-- Haskell 不需要括号来调用函数，所有的参数都只是在函数名之后列出来 +-- 因此，通常的函数调用模式是： +-- func arg1 arg2 arg3... +-- 你可以查看函数部分了解如何自行编写。 + +-- 字符串和字符 +"This is a string." -- 字符串 +'a' -- 字符 +'对于字符串你不能使用单引号。' -- 错误！ + +-- 连接字符串 +"Hello " ++ "world!" -- "Hello world!" + +-- 一个字符串是一系列字符 +['H', 'e', 'l', 'l', 'o'] -- "Hello" +"This is a string" !! 0 -- 'T' + + +---------------------------------------------------- +-- 列表和元组 +---------------------------------------------------- + +-- 一个列表中的每一个元素都必须是相同的类型。 +-- 下面两个列表等价 +[1, 2, 3, 4, 5] +[1..5] + +-- 区间也可以这样 +['A'..'F'] -- "ABCDEF" + +-- 你可以在区间中指定步进 +[0,2..10] -- [0, 2, 4, 6, 8, 10] +[5..1] -- 这样不行，因为 Haskell 默认递增 +[5,4..1] -- [5, 4, 3, 2, 1] + +-- 列表下标 +[0..] !! 5 -- 5 + +-- 在 Haskell 你可以使用无限列表 +[1..] -- 一个含有所有自然数的列表 + +-- 无限列表的原理是，Haskell 有“惰性求值”。 +-- 这意味着 Haskell 只在需要时才会计算。 +-- 所以当你获取列表的第 1000 项元素时，Haskell 会返回给你： +[1..] !! 999 -- 1000 +-- Haskell 计算了列表中第 1 至 1000 项元素，但这个无限列表中剩下的元素还不存在。 +-- Haskell 只有在需要时才会计算它们。 + +-- 连接两个列表 +[1..5] ++ [6..10] + +-- 往列表头增加元素 +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- 其它列表操作 +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +-- 列表推导 (list comprehension) +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +-- 附带条件 +[x*2 | x <-[1..5], x*2 > 4] -- [6, 8, 10] + +-- 元组中的每一个元素可以是不同类型，但是一个元组的长度是固定的 +-- 一个元组 +("haskell", 1) + +-- 获取元组中的元素（例如，一个含有 2 个元素的元祖） +fst ("haskell", 1) -- "haskell" +snd ("haskell", 1) -- 1 + +---------------------------------------------------- +-- 3. 函数 +---------------------------------------------------- + +-- 一个接受两个变量的简单函数 +add a b = a + b + +-- 注意，如果你使用 ghci (Hakell 解释器)，你需要使用 `let`，也就是 +-- let add a b = a + b + +-- 调用函数 +add 1 2 -- 3 + +-- 你也可以使用反引号中置函数名： +1 `add` 2 -- 3 + +-- 你也可以定义不带字母的函数名，这样你可以定义自己的操作符。 +-- 这里有一个做整除的操作符 +(//) a b = a `div` b +35 // 4 -- 8 + +-- Guard：一个在函数中做条件判断的简单方法 +fib x + | x < 2 = x + | otherwise = fib (x - 1) + fib (x - 2) + +-- 模式匹配与 Guard 类似。 +-- 这里给出了三个不同的 fib 定义。 +-- Haskell 会自动调用第一个符合参数模式的声明 +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- 元组的模式匹配 +foo (x, y) = (x + 1, y + 2) + +-- 列表的模式匹配 +-- 这里 `x` 是列表中第一个元素，`xs` 是列表剩余的部分。 +-- 我们可以实现自己的 map 函数： +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- 匿名函数带有一个反斜杠，后面跟着所有的参数 +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- 在 fold（在一些语言称 为`inject`）中使用匿名函数 +-- foldl1 意味着左折叠 (fold left), 并且使用列表中第一个值作为累加器的初始值。 +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. 其它函数 +---------------------------------------------------- + +-- 部分调用 +-- 如果你调用函数时没有给出所有参数，它就被“部分调用”。 +-- 它将返回一个接受余下参数的函数。 +add a b = a + b +foo = add 10 -- foo 现在是一个接受一个数并对其加 10 的函数 +foo 5 -- 15 + +-- 另一种等价写法 +foo = (+10) +foo 5 -- 15 + +-- 函列表合 +-- (.) 函数把其它函数链接到一起。 +-- 例如，这里 foo 是一个接受一个值的函数。 +-- 它对接受的值加 10，并对结果乘以 5，之后返回最后的值。 +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + +-- 修正优先级 +-- Haskell 有另外一个函数 `$` 可以改变优先级。 +-- `$` 使得 Haskell 先计算其右边的部分，然后调用左边的部分。 +-- 你可以使用 `$` 来移除多余的括号。 + +-- 修改前 +(even (fib 7)) -- true + +-- 修改后 +even . fib $ 7 -- true + +-- 等价地 +even $ fib 7 -- true + +---------------------------------------------------- +-- 5. 类型声明 +---------------------------------------------------- + +-- Haskell 有一个非常强大的类型系统，一切都有一个类型声明。 + +-- 一些基本的类型： +5 :: Integer +"hello" :: String +True :: Bool + +-- 函数也有类型 +-- `not` 接受一个布尔型返回一个布尔型 +-- not :: Bool -> Bool + +-- 这是接受两个参数的函数 +-- add :: Integer -> Integer -> Integer + +-- 当你定义一个值，声明其类型是一个好做法 +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. 控制流和 If 语句 +---------------------------------------------------- + +-- if 语句： +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- if 语句也可以有多行，注意缩进： +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- case 语句 +-- 解析命令行参数： +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + +-- Haskell 没有循环，它使用递归 +-- map 对一个列表中的每一个元素调用一个函数 +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- 你可以使用 map 来编写 for 函数 +for array func = map func array + +-- 调用 +for [0..5] $ \i -> show i + +-- 我们也可以像这样写 +for [0..5] show + +-- 你可以使用 foldl 或者 foldr 来分解列表 +-- foldl <fn> <initial value> <list> +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- 等价于 +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl 从左开始，foldr 从右 +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- 现在它等价于 +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. 数据类型 +---------------------------------------------------- + +-- 在 Haskell 中声明你自己的数据类型： +data Color = Red | Blue | Green + +-- 现在你可以在函数中使用它： +say :: Color -> String +say Red = "You are Red!" +say Blue = "You are Blue!" +say Green = "You are Green!" + +-- 你的数据类型也可以有参数： +data Maybe a = Nothing | Just a + +-- 这些都是 Maybe 类型： +Just "hello" -- `Maybe String` 类型 +Just 1 -- `Maybe Int` 类型 +Nothing -- 对任意 `a` 为 `Maybe a` 类型 + +---------------------------------------------------- +-- 8. Haskell IO +---------------------------------------------------- + +-- 虽然不解释 Monads 就无法完全解释 IO，但大致了解并不难。 + +-- 当执行一个 Haskell 程序时，函数 `main` 就被调用。 +-- 它必须返回一个类型 `IO ()` 的值。例如： +main :: IO () +main = putStrLn $ "Hello, sky! " ++ (say Blue) +-- putStrLn 的类型是 String -> IO () + +-- 如果你的程序输入 String 返回 String，那样编写 IO 是最简单的。 +-- 函数 +-- interact :: (String -> String) -> IO () +-- 输入一些文本，对其调用一个函数，并打印输出。 + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- 你可以认为一个 `IO ()` 类型的值是表示计算机做的一系列操作，类似命令式语言。 +-- 我们可以使用 `do` 声明来把动作连接到一起。 +-- 举个列子 +sayHello :: IO () +sayHello = do + putStrLn "What is your name?" + name <- getLine -- 这里接受一行输入并绑定至 "name" + putStrLn $ "Hello, " ++ name + +-- 练习：编写只读取一行输入的 `interact` + +-- 然而，`sayHello` 中的代码将不会被执行。唯一被执行的动作是 `main` 的值。 +-- 为了运行 `sayHello`，注释上面 `main` 的定义，替换为： +-- main = sayHello + +-- 让我们来更进一步理解刚才所使用的函数 `getLine` 是怎样工作的。它的类型是： +-- getLine :: IO String +-- 你可以认为一个 `IO a` 类型的值代表了一个运行时会生成一个 `a` 类型值的程序。 +-- （可能伴随其它行为） +-- 我们可以通过 `<-` 保存和重用这个值。 +-- 我们也可以实现自己的 `IO String` 类型函数： +action :: IO String +action = do + putStrLn "This is a line. Duh" + input1 <- getLine + input2 <- getLine + -- `do` 语句的类型是它的最后一行 + -- `return` 不是关键字，只是一个普通函数 + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- 我们可以像调用 `getLine` 一样调用它 +main'' = do + putStrLn "I will echo two lines!" + result <- action + putStrLn result + putStrLn "This was all, folks!" + +-- `IO` 类型是一个 "Monad" 的例子。 +-- Haskell 通过使用 Monad 使得其本身为纯函数式语言。 +-- 任何与外界交互的函数（即 IO）都在它的类型声明中标记为 `IO`。 +-- 这告诉我们什么样的函数是“纯洁的”(不与外界交互，不修改状态) ， +-- 什么样的函数不是 “纯洁的”。 +-- 这个功能非常强大，因为纯函数并发非常容易，由此在 Haskell 中做并发非常容易。 + +---------------------------------------------------- +-- 9. Haskell REPL +---------------------------------------------------- + +-- 键入 `ghci` 开始 REPL。 +-- 现在你可以键入 Haskell 代码。 +-- 任何新值都需要通过 `let` 来创建 +let foo = 5 + +-- 你可以通过命令 `:t` 查看任何值的类型 +>:t foo +foo :: Integer + +-- 你也可以运行任何 `IO ()`类型的动作 +> sayHello +What is your name? +Friend! +Hello, Friend! + +``` + +Haskell 还有许多内容，包括类型类 (typeclasses) 与 Monads。这些都是令 Haskell 编程非常有趣的好东西。我们最后给出 Haskell 的一个例子，一个快速排序的实现： + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +安装 Haskell 很简单。你可以[从这里获得](http://www.haskell.org/platform/)。 + +你可以从优秀的 +[Learn you a Haskell](http://learnyouahaskell.com/) 或者 +[Real World Haskell](http://book.realworldhaskell.org/) +找到更平缓的入门介绍。 diff --git a/zh-cn/java-cn.html.markdown b/zh-cn/java-cn.html.markdown index 4db4e91e..12afa59a 100755..100644 --- a/zh-cn/java-cn.html.markdown +++ b/zh-cn/java-cn.html.markdown @@ -1,12 +1,13 @@ --- - +name: java +category: language language: java +lang: zh-cn +filename: LearnJava-zh.java contributors: - ["Jake Prather", "http://github.com/JakeHP"] translators: - - ["Chenbo Li", "http://binarythink.net"] -filename: LearnJava.java - + - ["Chenbo Li", "http://binarythink.net"] --- Java是一个通用的程序语言, 包含并发, 基于类的面向对象等特性 @@ -123,7 +124,7 @@ public class LearnJava { // HashMaps /////////////////////////////////////// - // 操作符 + // 操作符 /////////////////////////////////////// System.out.println("\n->Operators"); @@ -148,7 +149,7 @@ public class LearnJava { // 位运算操作符 /* - ~ 补 + ~ 取反，求反码 << 带符号左移 >> 带符号右移 >>> 无符号右移 @@ -160,10 +161,13 @@ public class LearnJava { // 自增 int i = 0; System.out.println("\n->Inc/Dec-rementation"); - System.out.println(i++); //i = 1 后自增 - System.out.println(++i); //i = 2 前自增 - System.out.println(i--); //i = 1 后自减 - System.out.println(--i); //i = 0 前自减 + // ++ 和 -- 操作符使变量加或减1。放在变量前面或者后面的区别是整个表达 + // 式的返回值。操作符在前面时，先加减，后取值。操作符在后面时，先取值 + // 后加减。 + System.out.println(i++); // 后自增 i = 1, 输出0 + System.out.println(++i); // 前自增 i = 2, 输出2 + System.out.println(i--); // 后自减 i = 1, 输出2 + System.out.println(--i); // 前自减 i = 0, 输出0 /////////////////////////////////////// // 控制结构 @@ -191,7 +195,7 @@ public class LearnJava { } System.out.println("fooWhile Value: " + fooWhile); - // Do While循环 + // Do While循环 int fooDoWhile = 0; do { @@ -321,7 +325,7 @@ class Bicycle { // 方法声明的语法: // <作用域> <返回值类型> <方法名>(<参数列表>) public int getCadence() { - retur450635425n cadence; + return cadence; } // void返450635425回值函数没有返回值 diff --git a/zh-cn/javascript-cn.html.markdown b/zh-cn/javascript-cn.html.markdown new file mode 100644 index 00000000..bdef0099 --- /dev/null +++ b/zh-cn/javascript-cn.html.markdown @@ -0,0 +1,496 @@ +--- +language: javascript +category: language +name: javascript +filename: javascript-zh.js +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +translators: + - ["Chenbo Li", "http://binarythink.net"] + - ["Guodong Qu", "https://github.com/jasonqu"] +lang: zh-cn +--- + +Javascript于1995年由网景公司的Brendan Eich发明。 +最初发明的目的是作为一个简单的网站脚本语言，来作为 +复杂网站应用java的补充。但由于它与网页结合度很高并且由浏览器内置支持， +所以javascript变得比java在前端更为流行了。 + +不过 JavaScript 可不仅仅只用于浏览器： Node.js，一个基于Google Chrome V8引擎的独立运行时环境，也越来越流行。 + +很欢迎来自您的反馈，您可以通过下列方式联系到我： +[@adambrenecki](https://twitter.com/adambrenecki), 或者 +[adam@brenecki.id.au](mailto:adam@brenecki.id.au). + +```js +// 注释方式和C很像，这是单行注释 +/* 这是多行 + 注释 */ + +// 语句可以以分号结束 +doStuff(); + +// ... 但是分号也可以省略，每当遇到一个新行时，分号会自动插入（除了一些特殊情况）。 +doStuff() + +// 因为这些特殊情况会导致意外的结果，所以我们在这里保留分号。 + +/////////////////////////////////// +// 1. 数字、字符串与操作符 + +// Javascript 只有一种数字类型(即 64位 IEEE 754 双精度浮点 double)。 +// double 有 52 位表示尾数，足以精确存储大到 9✕10¹⁵ 的整数。 +3; // = 3 +1.5; // = 1.5 + +// 所有基本的算数运算都如你预期。 +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// 包括无法整除的除法。 +5 / 2; // = 2.5 + +// 位运算也和其他语言一样；当你对浮点数进行位运算时， +// 浮点数会转换为*至多* 32 位的无符号整数。 +1 << 2; // = 4 + +// 括号可以决定优先级。 +(1 + 3) * 2; // = 8 + +// 有三种非数字的数字类型 +Infinity; // 1/0 的结果 +-Infinity; // -1/0 的结果 +NaN; // 0/0 的结果 + +// 也有布尔值。 +true; +false; + +// 可以通过单引号或双引号来构造字符串。 +'abc'; +"Hello, world"; + +// 用！来取非 +!true; // = false +!false; // = true + +// 相等 === +1 === 1; // = true +2 === 1; // = false + +// 不等 != +1 !== 1; // = false +2 !== 1; // = true + +// 更多的比较操作符 +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// 字符串用+连接 +"Hello " + "world!"; // = "Hello world!" + +// 字符串也可以用 < 、> 来比较 +"a" < "b"; // = true + +// 使用“==”比较时会进行类型转换... +"5" == 5; // = true +null == undefined; // = true + +// ...除非你是用 === +"5" === 5; // = false +null === undefined; // = false + +// ...但会导致奇怪的行为 +13 + !0; // 14 +"13" + !0; // '13true' + +// 你可以用`charAt`来得到字符串中的字符 +"This is a string".charAt(0); // = 'T' + +// ...或使用 `substring` 来获取更大的部分。 +"Hello world".substring(0, 5); // = "Hello" + +// `length` 是一个属性，所以不要使用 (). +"Hello".length; // = 5 + +// 还有两个特殊的值：`null`和`undefined` +null; // 用来表示刻意设置的空值 +undefined; // 用来表示还没有设置的值(尽管`undefined`自身实际是一个值) + +// false, null, undefined, NaN, 0 和 "" 都是假的；其他的都视作逻辑真 +// 注意 0 是逻辑假而 "0"是逻辑真，尽管 0 == "0"。 + +/////////////////////////////////// +// 2. 变量、数组和对象 + +// 变量需要用`var`关键字声明。Javascript是动态类型语言， +// 所以你无需指定类型。 赋值需要用 `=` +var someVar = 5; + +// 如果你在声明时没有加var关键字，你也不会得到错误... +someOtherVar = 10; + +// ...但是此时这个变量就会在全局作用域被创建，而非你定义的当前作用域 + +// 没有被赋值的变量都会被设置为undefined +var someThirdVar; // = undefined + +// 对变量进行数学运算有一些简写法： +someVar += 5; // 等价于 someVar = someVar + 5; someVar 现在是 10 +someVar *= 10; // 现在 someVar 是 100 + +// 自增和自减也有简写 +someVar++; // someVar 是 101 +someVar--; // 回到 100 + +// 数组是任意类型组成的有序列表 +var myArray = ["Hello", 45, true]; + +// 数组的元素可以用方括号下标来访问。 +// 数组的索引从0开始。 +myArray[1]; // = 45 + +// 数组是可变的，并拥有变量 length。 +myArray.push("World"); +myArray.length; // = 4 + +// 在指定下标添加/修改 +myArray[3] = "Hello"; + +// javascript中的对象相当于其他语言中的“字典”或“映射”：是键-值对的无序集合。 +var myObj = {key1: "Hello", key2: "World"}; + +// 键是字符串，但如果键本身是合法的js标识符，则引号并非是必须的。 +// 值可以是任意类型。 +var myObj = {myKey: "myValue", "my other key": 4}; + +// 对象属性的访问可以通过下标 +myObj["my other key"]; // = 4 + +// ... 或者也可以用 . ，如果属性是合法的标识符 +myObj.myKey; // = "myValue" + +// 对象是可变的；值也可以被更改或增加新的键 +myObj.myThirdKey = true; + +// 如果你想要获取一个还没有被定义的值，那么会返回undefined +myObj.myFourthKey; // = undefined + +/////////////////////////////////// +// 3. 逻辑与控制结构 + +// 本节介绍的语法与Java的语法几乎完全相同 + +// `if`语句和其他语言中一样。 +var count = 1; +if (count == 3){ + // count 是 3 时执行 +} else if (count == 4){ + // count 是 4 时执行 +} else { + // 其他情况下执行 +} + +// while循环 +while (true) { + // 无限循环 +} + +// Do-while 和 While 循环很像 ，但前者会至少执行一次 +var input; +do { + input = getInput(); +} while (!isValid(input)) + +// `for`循环和C、Java中的一样： +// 初始化; 继续执行的条件; 迭代。 +for (var i = 0; i < 5; i++){ + // 遍历5次 +} + +// && 是逻辑与, || 是逻辑或 +if (house.size == "big" && house.colour == "blue"){ + house.contains = "bear"; +} +if (colour == "red" || colour == "blue"){ + // colour是red或者blue时执行 +} + +// && 和 || 是“短路”语句，它在设定初始化值时特别有用 +var name = otherName || "default"; + +// `switch`语句使用`===`检查相等性。 +// 在每一个case结束时使用 'break' +// 否则其后的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. 函数、作用域、闭包 + +// JavaScript 函数由`function`关键字定义 +function myFunction(thing){ + return thing.toUpperCase(); +} +myFunction("foo"); // = "FOO" + +// 注意被返回的值必须开始于`return`关键字的那一行， +// 否则由于自动的分号补齐，你将返回`undefined`。 +// 在使用Allman风格的时候要注意. +function myFunction() +{ + return // <- 分号自动插在这里 + { + thisIsAn: 'object literal' + } +} +myFunction(); // = undefined + +// javascript中函数是一等对象，所以函数也能够赋给一个变量， +// 并且被作为参数传递 —— 比如一个事件处理函数： +function myFunction(){ + // 这段代码将在5秒钟后被调用 +} +setTimeout(myFunction, 5000); +// 注意：setTimeout不是js语言的一部分，而是由浏览器和Node.js提供的。 + +// 函数对象甚至不需要声明名称 —— 你可以直接把一个函数定义写到另一个函数的参数中 +setTimeout(function(){ + // 这段代码将在5秒钟后被调用 +}, 5000); + +// JavaScript 有函数作用域；函数有其自己的作用域而其他的代码块则没有。 +if (true){ + var i = 5; +} +i; // = 5 - 并非我们在其他语言中所期望得到的undefined + +// 这就导致了人们经常使用的“立即执行匿名函数”的模式， +// 这样可以避免一些临时变量扩散到全局作用域去。 +(function(){ + var temporary = 5; + // 我们可以访问修改全局对象（"global object"）来访问全局作用域， + // 在web浏览器中是`window`这个对象。 + // 在其他环境如Node.js中这个对象的名字可能会不同。 + window.permanent = 10; +})(); +temporary; // 抛出引用异常ReferenceError +permanent; // = 10 + +// javascript最强大的功能之一就是闭包。 +// 如果一个函数在另一个函数中定义，那么这个内部函数就拥有外部函数的所有变量的访问权， +// 即使在外部函数结束之后。 +function sayHelloInFiveSeconds(name){ + var prompt = "Hello, " + name + "!"; + // 内部函数默认是放在局部作用域的， + // 就像是用`var`声明的。 + function inner(){ + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout是异步的，所以 sayHelloInFiveSeconds 函数会立即退出， + // 而 setTimeout 会在后面调用inner + // 然而，由于inner是由sayHelloInFiveSeconds“闭合包含”的， + // 所以inner在其最终被调用时仍然能够访问`prompt`变量。 +} +sayHelloInFiveSeconds("Adam"); // 会在5秒后弹出 "Hello, Adam!" + + +/////////////////////////////////// +// 5. 对象、构造函数与原型 + +// 对象可以包含方法。 +var myObj = { + myFunc: function(){ + return "Hello world!"; + } +}; +myObj.myFunc(); // = "Hello world!" + +// 当对象中的函数被调用时，这个函数可以通过`this`关键字访问其依附的这个对象。 +myObj = { + myString: "Hello world!", + myFunc: function(){ + return this.myString; + } +}; +myObj.myFunc(); // = "Hello world!" + +// 但这个函数访问的其实是其运行时环境，而非定义时环境，即取决于函数是如何调用的。 +// 所以如果函数被调用时不在这个对象的上下文中，就不会运行成功了。 +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// 相应的，一个函数也可以被指定为一个对象的方法，并且可以通过`this`访问 +// 这个对象的成员，即使在函数被定义时并没有依附在对象上。 +var myOtherFunc = function(){ + return this.myString.toUpperCase(); +} +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "HELLO WORLD!" + +// 当我们通过`call`或者`apply`调用函数的时候，也可以为其指定一个执行上下文。 +var anotherFunc = function(s){ + return this.myString + s; +} +anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!" + +// `apply`函数几乎完全一样，只是要求一个array来传递参数列表。 +anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!" + +// 当一个函数接受一系列参数，而你想传入一个array时特别有用。 +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// 但是`call`和`apply`只是临时的。如果我们希望函数附着在对象上，可以使用`bind`。 +var boundFunc = anotherFunc.bind(myObj); +boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!" + +// `bind` 也可以用来部分应用一个函数（柯里化）。 +var product = function(a, b){ return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// 当你通过`new`关键字调用一个函数时，就会创建一个对象， +// 而且可以通过this关键字访问该函数。 +// 设计为这样调用的函数就叫做构造函数。 +var MyConstructor = function(){ + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// 每一个js对象都有一个‘原型’。当你要访问一个实际对象中没有定义的一个属性时， +// 解释器就回去找这个对象的原型。 + +// 一些JS实现会让你通过`__proto__`属性访问一个对象的原型。 +// 这虽然对理解原型很有用，但是它并不是标准的一部分； +// 我们后面会介绍使用原型的标准方式。 +var myObj = { + myString: "Hello world!" +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 + +// 函数也可以工作。 +myObj.myFunc() // = "hello world!" + +// 当然，如果你要访问的成员在原型当中也没有定义的话，解释器就会去找原型的原型，以此类推。 +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + +// 这其中并没有对象的拷贝；每个对象实际上是持有原型对象的引用。 +// 这意味着当我们改变对象的原型时，会影响到其他以这个原型为原型的对象。 +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + +// 我们知道 `__proto__` 并非标准规定，实际上也没有标准办法来修改一个已存在对象的原型。 +// 然而，我们有两种方式为指定原型创建一个新的对象。 + +// 第一种方式是 Object.create，这个方法是在最近才被添加到Js中的， +// 因此并不是所有的JS实现都有这个方法 +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// 第二种方式可以在任意版本中使用，不过必须通过构造函数。 +// 构造函数有一个属性prototype。但是它 *不是* 构造函数本身的原型；相反， +// 是通过构造函数和new关键字创建的新对象的原型。 +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function(){ + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// 字符串和数字等内置类型也有通过构造函数来创建的包装类型 +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// 但是它们并非严格等价 +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0){ + // 这段代码不会执行，因为0代表假 +} + +// 不过，包装类型和内置类型共享一个原型， +// 所以你实际可以给内置类型也增加一些功能，例如对string： +String.prototype.firstCharacter = function(){ + return this.charAt(0); +} +"abc".firstCharacter(); // = "a" + +// 这个技巧经常用在“代码填充”中，来为老版本的javascript子集增加新版本js的特性， +// 这样就可以在老的浏览器中使用新功能了。 + +// 比如，我们知道Object.create并没有在所有的版本中都实现， +// 但是我们仍然可以通过“代码填充”来实现兼容： +if (Object.create === undefined){ // 如果存在则不覆盖 + Object.create = function(proto){ + // 用正确的原型来创建一个临时构造函数 + var Constructor = function(){}; + Constructor.prototype = proto; + // 之后用它来创建一个新的对象 + return new Constructor(); + } +} +``` + +## 更多阅读 + +[Mozilla 开发者 +网络](https://developer.mozilla.org/en-US/docs/Web/JavaScript) 提供了优秀的介绍 +Javascript如何在浏览器中使用的文档。而且它是wiki，所以你也可以自行编辑来分享你的知识。 + +MDN的 [A re-introduction to +JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +覆盖了这里提到的绝大多数话题的细节。该导引的大多数内容被限定在只是Javascript这个语言本身； +如果你想了解Javascript是如何在网页中被应用的，那么可以查看 +[Document Object +Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) 是本参考的另一个版本，并包含了挑战习题。 + +[Javascript Garden](http://bonsaiden.github.io/JavaScript-Garden/) 是一个深入 +讲解所有Javascript反直觉部分的导引。 + +[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) 是一个经典的指导参考书。 + +除了这篇文章的直接贡献者之外，这篇文章也参考了这个网站上 +Louie Dinh 的 Python 教程，以及 Mozilla开发者网络上的[JS +Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)。 diff --git a/zh-cn/javascript.html.markdown b/zh-cn/javascript.html.markdown deleted file mode 100755 index dd04c8a5..00000000 --- a/zh-cn/javascript.html.markdown +++ /dev/null @@ -1,415 +0,0 @@ ---- -language: javascript -author: Adam Brenecki -author_url: http://adam.brenecki.id.au -translator: Chenbo Li -translator_url: http://binarythink.net ---- - -Javascript于1995年由网景公司的Brendan Eich发明。 -最初发明的目的是作为一个简单的网站脚本语言，来作为 -复杂网站应用java的补充。但由于javascript和网站结合度很高 -所以javascript逐渐变得比java在前端更为流行了。 - -JavaScript 不仅仅只可以用于浏览器, 也可用于 Node.js 等后台环境。 - -很欢迎来自您的反馈，您可以通过下列方式联系到我： -[@adambrenecki](https://twitter.com/adambrenecki), 或者 -[adam@brenecki.id.au](mailto:adam@brenecki.id.au). - -```js -// 注释方式和C很像，这是单行注释 -/* 这是多行 - 注释 */ - -// 语句可以以分号结束 -doStuff(); - -// ... 但是分号也可以省略，每当遇到一个新行时，分号会自动插入 -doStuff() - -// 我们在这里会去掉分号，但是否添加最后的分号取决于你个人的习惯 -// 及你所在团队的编程风格 - -/////////////////////////////////// -// 1. 数字、字符串与操作符 - -// Javascript 只有一种数字类型 (即 64位 IEEE 754 双精度浮点). -3 // = 3 -1.5 // = 1.5 - -// 所有基本的算数运算 -1 + 1 // = 2 -8 - 1 // = 7 -10 * 2 // = 20 -35 / 5 // = 7 - -// 包括无法整除的除法 -5 / 2 // = 2.5 - -// 位运算也和其他语言一样。当你对浮点数进行位运算时， -// 浮点数会转换为至多 32 位的无符号整数 -1 << 2 // = 4 - -// 括号可以决定优先级 -(1 + 3) * 2 // = 8 - -// 有三种非数字的数字类型 -Infinity // 1/0 的结果 --Infinity // -1/0 的结果 -NaN // 0/0 的结果 - -// 也有布尔值 -true -false - -// 可以通过单引号或双引号来构造字符串 -'abc' -"Hello, world" - -// 用！来取非 -!true // = false -!false // = true - -// 相等 == -1 == 1 // = true -2 == 1 // = false - -// 不等 != -1 != 1 // = false -2 != 1 // = true - -// 更多的比较操作符 -1 < 10 // = true -1 > 10 // = false -2 <= 2 // = true -2 >= 2 // = true - -// 字符串用+连接 -"Hello " + "world!" // = "Hello world!" - -// 字符串也可以用 < 、> 来比较 -"a" < "b" // = true - -// 比较时会进行类型转换... -"5" == 5 // = true - -// ...除非你是用 === -"5" === 5 // = false - -// 你可以用charAt来得到字符串中的字符 -"This is a string".charAt(0) - -// 还有两个特殊的值：null和undefined -null // 用来表示刻意设置成的空值 -undefined // 用来表示还没有设置的值 - -// null, undefined, NaN, 0 和 "" 都是假的（false），其他的都视作逻辑真 -// 注意 0 是逻辑假而 "0"是逻辑真, 尽管 0 == "0". - -/////////////////////////////////// -// 2. 变量、数组和对象 - -// 变量需要用 var 这个关键字声明. Javascript是动态类型语言 -// 所以你在声明时无需指定类型。 赋值需要用 = -var someVar = 5 - -// 如果你在声明时没有加var关键字，你也不会得到错误 -someOtherVar = 10 - -// ...但是此时这个变量就会拥有全局的作用域，而非当前作用域 - -// 没有被赋值的变量都会返回undefined这个值 -var someThirdVar // = undefined - -// 对变量进行数学运算有一些简写法 -someVar += 5 // 等价于 someVar = someVar + 5; someVar 现在是 10 -someVar *= 10 // 现在 someVar 是 100 - -// 自增和自减也有简写 -someVar++ // someVar 是 101 -someVar-- // 回到 100 - -// 数组是任意类型组成的有序列表 -var myArray = ["Hello", 45, true] - -// 数组的元素可以用方括号下标来访问 -// 数组的索引从0开始 -myArray[1] // = 45 - -// javascript中的对象相当于其他语言中的字典或映射：是键-值的集合 -{key1: "Hello", key2: "World"} - -// 键是字符串，但是引号也并非是必须的，如果键本身是合法的js标识符 -// 而值则可以是任意类型的值 -var myObj = {myKey: "myValue", "my other key": 4} - -// 对象的访问可以通过下标 -myObj["my other key"] // = 4 - -// ... 或者也可以用 . ，如果属性是合法的标识符 -myObj.myKey // = "myValue" - -// 对象是可变的，键和值也可以被更改或增加 -myObj.myThirdKey = true - -// 如果你想要访问一个还没有被定义的属性，那么会返回undefined -myObj.myFourthKey // = undefined - -/////////////////////////////////// -// 3. 逻辑与控制结构 - -// if语句和其他语言中一样 -var count = 1 -if (count == 3){ - // count 是 3 时执行 -} else if (count == 4) { - // count 是 4 时执行 -} else { - // 其他情况下执行 -} - -// while循环 -while (true) { - // 无限循环 -} - -// Do-while 和 While 循环很像 ，但前者会至少执行一次 -var input -do { - input = getInput() -} while (!isValid(input)) - -// for循环和C、Java中的一样 -// 初始化; 继续执行的条件; 遍历后执行. -for (var i = 0; i < 5; i++){ - // 遍历5次 -} - -// && 是逻辑与, || 是逻辑或 -if (house.size == "big" && house.colour == "blue"){ - house.contains = "bear" -} -if (colour == "red" || colour == "blue"){ - // colour是red或者blue时执行 -} - -// && 和 || 是“短路”语句，在初始化值时会变得有用 -var name = otherName || "default" - -/////////////////////////////////// -// 4. 函数、作用域、闭包 - -// JavaScript 函数由function关键字定义 -function myFunction(thing){ - return thing.toUpperCase() -} -myFunction("foo") // = "FOO" - -// 函数也可以是匿名的： -function(thing){ - return thing.toLowerCase() -} -// (我们无法调用此函数，因为我们不知道这个函数的名字) - -// javascript中的函数也是对象，所以函数也能够赋给一个变量，并且被传递 -// 比如一个事件处理函数： -function myFunction(){ - // this code will be called in 5 seconds' time -} -setTimeout(myFunction, 5000) - -// 你甚至可以直接把一个函数写到另一个函数的参数中 - -setTimeout(function myFunction(){ - // 5秒之后会执行这里的代码 -}, 5000) - -// JavaScript 仅有函数作用于，而其他的语句则没有作用域 -if (true){ - var i = 5 -} -i // = 5 - 并非我们在其他语言中所得到的undefined - -// 这就导致了人们经常用一种叫做“即使执行匿名函数”的模式 -// 这样可以避免一些临时变量扩散到外边去 -function(){ - var temporary = 5 - // 我们可以访问一个全局对象来访问全局作用域 - // 在浏览器中是 'window' 这个对象。 - // 在Node.js中这个对象的名字可能会不同。 - window.permanent = 10 - // 或者，我们也可以把var去掉就行了 - permanent2 = 15 -}() -temporary // 抛出引用异常 -permanent // = 10 -permanent2 // = 15 - -// javascript最强大的功能之一就是闭包 -// 如果一个函数在另一个函数中定义，那么这个函数就拥有外部函数的所有访问权 -function sayHelloInFiveSeconds(name){ - var prompt = "Hello, " + name + "!" - function inner(){ - alert(prompt) - } - setTimeout(inner, 5000) - // setTimeout 是异步的，所以这个函数会马上终止不会等待。 - // 然而，在5秒结束后，inner函数仍然会弹出prompt信息。 -} -sayHelloInFiveSeconds("Adam") // 会在5秒后弹出 "Hello, Adam!" - -/////////////////////////////////// -// 5. 对象、构造函数与原型 - -// 对象包含方法 -var myObj = { - myFunc: function(){ - return "Hello world!" - } -} -myObj.myFunc() // = "Hello world!" - -// 当对象中的函数被调用时，这个函数就可以通过this关键字访问这个对象 -myObj = { - myString: "Hello world!", - myFunc: function(){ - return this.myString - } -} -myObj.myFunc() // = "Hello world!" - -// 但这个函数访问的其实是其运行时环境，而非定义时环境 -// 所以如果函数所在的环境不在当前对象的环境中运行时，就运行不成功了 -var myFunc = myObj.myFunc -myFunc() // = undefined - -// 相应的，一个函数也可以被指定为一个对象的方法，并且用过this可以访问 -// 这个对象的成员，即使在定义时并没有绑定任何值 -var myOtherFunc = function(){ - return this.myString.toUpperCase() -} -myObj.myOtherFunc = myOtherFunc -myObj.myOtherFunc() // = "HELLO WORLD!" - -// 当你通过new关键字调用一个函数时，就会生成一个对象 -// 而对象的成员需要通过this来定义。 -// 这样的函数就叫做构造函数 - -var MyConstructor = function(){ - this.myNumber = 5 -} -myNewObj = new MyConstructor() // = {myNumber: 5} -myNewObj.myNumber // = 5 - -// 每一个js对象都有一个原型，当你要访问一个没有定义过的成员时， -// 解释器就回去找这个对象的原型 - -// 有一些JS实现会让你通过一个对象的__proto__方法访问这个原型。 -// 这虽然对理解这个对象很有用，但是这并不是标准的一部分 -// 我们之后会通过标准方式来访问原型。 -var myObj = { - myString: "Hello world!", -} -var myPrototype = { - meaningOfLife: 42, - myFunc: function(){ - return this.myString.toLowerCase() - } -} -myObj.__proto__ = myPrototype -myObj.meaningOfLife // = 42 - -// This works for functions, too. -myObj.myFunc() // = "hello world!" - -// 当然，如果你要访问的成员在原型当中也没有定义的话，解释器就会去找原型的原型。 -myPrototype.__proto__ = { - myBoolean: true -} -myObj.myBoolean // = true - -// 这其中并没有对象的拷贝。每个对象的原型实际上是持有原型对象的引用 -// 这说明当我们改变对象的原型时，会影响到其他以这个原型为原型的对象 -myPrototype.meaningOfLife = 43 -myObj.meaningOfLife // = 43 - -// 我们知道 __proto__ 并非标准规定，实际上也没有办法更改已经指定好的原型。 -// 但是，我们有两种方式可以为新的对象指定原型。 - -// 第一种方式是 Object.create，这个方法是在最近才被添加到Js中的 -// 也因此并不是所有的JS实现都有这个放啊 -var myObj = Object.create(myPrototype) -myObj.meaningOfLife // = 43 - -// 第二种方式可以在任意版本中使用，不过需要通过构造函数。 -// 构造函数有一个属性prototype。但是这 *不是* 构造函数本身的函数 -// 而是通过构造函数和new关键字生成新对象时自动生成的。 -myConstructor.prototype = { - getMyNumber: function(){ - return this.myNumber - } -} -var myNewObj2 = new myConstructor() -myNewObj2.getMyNumber() // = 5 - -// 字符串和数字等内置类型也有通过构造函数来创建的包装类型 -var myNumber = 12 -var myNumberObj = new Number(12) -myNumber == myNumberObj // = true - -// 但是它们并非严格等价 -typeof(myNumber) // = 'number' -typeof(myNumberObj) // = 'object' -myNumber === myNumberObj // = false -if (0){ - // 这段代码不会执行，因为0代表假 -} -if (Number(0)){ - // 这段代码会执行，因为Number(0)代表真 -} - -// 但是，包装类型和内置类型共享一个原型 -// 这样你就可以给内置类型也增加一些功能 -String.prototype.firstCharacter = function(){ - return this.charAt(0) -} -"abc".firstCharacter() // = "a" - -// 这个技巧可以用来用老版本的javascript子集来是实现新版本js的功能 -// 这样就可以在老的浏览器中使用新功能了。 - -// 比如，我们知道Object.create并没有在所有的版本中都实现 -// 但是我们仍然可以通过这个技巧来使用 -if (Object.create === undefined){ // 如果存在则不覆盖 - Object.create = function(proto){ - // 用正确的原型来创建一个临时构造函数 - var Constructor = function(){} - Constructor.prototype = proto - // 之后用它来创建一个新的对象 - return new Constructor() - } -} -``` - -## 更多阅读 - -[Mozilla 开发者 -网络](https://developer.mozilla.org/en-US/docs/Web/JavaScript) 提供了很好的 -Javascript文档，并且由于是wiki，所以你也可以自行编辑来分享你的知识。 -wiki, so as you learn more you can help others out by sharing your own -knowledge. - -MDN的 [A re-introduction to -JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) -覆盖了这里提到的绝大多数话题，大多数只是Javascript这个语言本身。 -如果你想了解Javascript是如何在网页中被应用的，那么可以查看 -[Document Object -Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) - -[Javascript Garden](http://bonsaiden.github.io/JavaScript-Garden/) 是一个深入 -讲解所有Javascript反直觉部分的一本书 - -除了这篇文章的直接贡献者之外，这篇文章也参考了这个网站上 -Louie Dinh 的 Python 教程，以及 Mozilla开发者网络上的[JS -Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) diff --git a/zh-cn/json-cn.html.markdown b/zh-cn/json-cn.html.markdown new file mode 100644 index 00000000..3a8db2cf --- /dev/null +++ b/zh-cn/json-cn.html.markdown @@ -0,0 +1,51 @@ +--- +language: json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] +translators: + - ["Zach Zhang", "https://github.com/checkcheckzz"] +filename: learnjson-cn.json +lang: zh-cn +--- + +因为JSON是一个极其简单的数据交换形式，这个最有可能将会是曾经最简单 +的Learn X in Y Minutes。 + +最纯正形式的JSON没有实际的注解，但是大多数解析器将会 +接受C-风格(//, /\* \*/)的注解。为了这个目的，但是， +一切都将会是100%有效的JSON。幸亏，它是不言自明的。 + +```json +{ + "numbers": 0, + "strings": "Hellø, wørld. All unicode is allowed, along with \"escaping\".", + "has bools?": true, + "nothingness": null, + + "big number": 1.2e+100, + + "objects": { + "comment": "Most of your structure will come from objects.", + + "array": [0, 1, 2, 3, "Arrays can have anything in them.", 5], + + "another object": { + "comment": "These things can be nested, very useful." + } + }, + + "silliness": [ + { + "sources of potassium": ["bananas"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "that was short": "And, you're done. You now know everything JSON has to offer." +} +``` diff --git a/zh-cn/julia-cn.html.markdown b/zh-cn/julia-cn.html.markdown new file mode 100644 index 00000000..1f91d52c --- /dev/null +++ b/zh-cn/julia-cn.html.markdown @@ -0,0 +1,729 @@ +--- +language: Julia +filename: learn-julia-zh.jl +contributors: + - ["Jichao Ouyang", "http://oyanglul.us"] +translators: + - ["Jichao Ouyang", "http://oyanglul.us"] +lang: zh-cn +--- + +```ruby +# 单行注释只需要一个井号 +#= 多行注释 + 只需要以 '#=' 开始 '=#' 结束 + 还可以嵌套. +=# + +#################################################### +## 1. 原始类型与操作符 +#################################################### + +# Julia 中一切皆是表达式。 + +# 这是一些基本数字类型. +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# 支持所有的普通中缀操作符。 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # 用 Int 除 Int 永远返回 Float +div(5, 2) # => 2 # 使用 div 截断小数点 +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # 次方, 不是二进制 xor +12 % 10 # => 2 + +# 用括号提高优先级 +(1 + 3) * 2 # => 8 + +# 二进制操作符 +~2 # => -3 # 非 +3 & 5 # => 1 # 与 +2 | 4 # => 6 # 或 +2 $ 4 # => 6 # 异或 +2 >>> 1 # => 1 # 逻辑右移 +2 >> 1 # => 1 # 算术右移 +2 << 1 # => 4 # 逻辑/算术 右移 + +# 可以用函数 bits 查看二进制数。 +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# 布尔值是原始类型 +true +false + +# 布尔操作符 +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# 比较可以串联 +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# 字符串可以由 " 创建 +"This is a string." + +# 字符字面量可用 ' 创建 +'a' + +# 可以像取数组取值一样用 index 取出对应字符 +"This is a string"[1] # => 'T' # Julia 的 index 从 1 开始 :( +# 但是对 UTF-8 无效, +# 因此建议使用遍历器 (map, for loops, 等). + +# $ 可用于字符插值: +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# 可以将任何 Julia 表达式放入括号。 + +# 另一种格式化字符串的方式是 printf 宏. +@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 + +# 打印字符串很容易 +println("I'm Julia. Nice to meet you!") + +#################################################### +## 2. 变量与集合 +#################################################### + +# 给变量赋值就是声明变量 +some_var = 5 # => 5 +some_var # => 5 + +# 访问未声明变量会抛出异常 +try + some_other_var # => ERROR: some_other_var not defined +catch e + println(e) +end + +# 变量名需要以字母开头. +# 之后任何字母，数字，下划线，叹号都是合法的。 +SomeOtherVar123! = 6 # => 6 + +# 甚至可以用 unicode 字符 +☃ = 8 # => 8 +# 用数学符号非常方便 +2 * π # => 6.283185307179586 + +# 注意 Julia 的命名规约: +# +# * 变量名为小写，单词之间以下划线连接('\_')。 +# +# * 类型名以大写字母开头，单词以 CamelCase 方式连接。 +# +# * 函数与宏的名字小写，无下划线。 +# +# * 会改变输入的函数名末位为 !。 +# 这类函数有时被称为 mutating functions 或 in-place functions. + +# 数组存储一列值，index 从 1 开始。 +a = Int64[] # => 0-element Int64 Array + +# 一维数组可以以逗号分隔值的方式声明。 +b = [4, 5, 6] # => 包含 3 个 Int64 类型元素的数组: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# 二维数组以分号分隔维度。 +matrix = [1 2; 3 4] # => 2x2 Int64 数组: [1 2; 3 4] + +# 使用 push! 和 append! 往数组末尾添加元素 +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# 用 pop 弹出末尾元素 +pop!(b) # => 6 and b is now [4,5] + +# 可以再放回去 +push!(b,6) # b 又变成了 [4,5,6]. + +a[1] # => 1 # 永远记住 Julia 的 index 从 1 开始! + +# 用 end 可以直接取到最后索引. 可用作任何索引表达式 +a[end] # => 6 + +# 还支持 shift 和 unshift +shift!(a) # => 返回 1，而 a 现在时 [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# 以叹号结尾的函数名表示它会改变参数的值 +arr = [5,4,6] # => 包含三个 Int64 元素的数组: [5,4,6] +sort(arr) # => [4,5,6]; arr 还是 [5,4,6] +sort!(arr) # => [4,5,6]; arr 现在是 [4,5,6] + +# 越界会抛出 BoundsError 异常 +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# 错误会指出发生的行号，包括标准库 +# 如果你有 Julia 源代码，你可以找到这些地方 + +# 可以用 range 初始化数组 +a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5] + +# 可以切割数组 +a[1:3] # => [1, 2, 3] +a[2:end] # => [2, 3, 4, 5] + +# 用 splice! 切割原数组 +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr 变成了 [3,5] + +# 用 append! 连接数组 +b = [1,2,3] +append!(a,b) # a 变成了 [1, 2, 3, 4, 5, 1, 2, 3] + +# 检查元素是否在数组中 +in(1, a) # => true + +# 用 length 获得数组长度 +length(a) # => 8 + +# Tuples 是 immutable 的 +tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# 大多数组的函数同样支持 tuples +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +# 可以将 tuples 元素分别赋给变量 +a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3 + +# 不用括号也可以 +d, e, f = 4, 5, 6 # => (4,5,6) + +# 单元素 tuple 不等于其元素值 +(1,) == 1 # => false +(1) == 1 # => true + +# 交换值 +e, d = d, e # => (5,4) # d is now 5 and e is now 4 + + +# 字典Dictionaries store mappings +empty_dict = Dict() # => Dict{Any,Any}() + +# 也可以用字面量创建字典 +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# 用 [] 获得键值 +filled_dict["one"] # => 1 + +# 获得所有键 +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# 注意，键的顺序不是插入时的顺序 + +# 获得所有值 +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# 注意，值的顺序也一样 + +# 用 in 检查键值是否已存在，用 haskey 检查键是否存在 +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# 获取不存在的键的值会抛出异常 +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# 使用 get 可以提供默认值来避免异常 +# get(dictionary,key,default_value) +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# 用 Sets 表示无序不可重复的值的集合 +empty_set = Set() # => Set{Any}() +# 初始化一个 Set 并定义其值 +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# 添加值 +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# 检查是否存在某值 +in(2, filled_set) # => true +in(10, filled_set) # => false + +# 交集，并集，差集 +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + + +#################################################### +## 3. 控制流 +#################################################### + +# 声明一个变量 +some_var = 5 + +# 这是一个 if 语句，缩进不是必要的 +if some_var > 10 + println("some_var is totally bigger than 10.") +elseif some_var < 10 # elseif 是可选的. + println("some_var is smaller than 10.") +else # else 也是可选的. + println("some_var is indeed 10.") +end +# => prints "some var is smaller than 10" + + +# For 循环遍历 +# Iterable 类型包括 Range, Array, Set, Dict, 以及 String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # 可用 $ 将 variables 或 expression 转换为字符串into strings +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# You can use 'in' instead of '='. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# While 循环 +x = 0 +while x < 4 + println(x) + x += 1 # x = x + 1 +end +# prints: +# 0 +# 1 +# 2 +# 3 + +# 用 try/catch 处理异常 +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. 函数 +#################################################### + +# 用关键字 'function' 可创建一个新函数 +#function name(arglist) +# body... +#end +function add(x, y) + println("x is $x and y is $y") + + # 最后一行语句的值为返回 + x + y +end + +add(5, 6) # => 在 "x is 5 and y is 6" 后会打印 11 + +# 还可以定义接收可变长参数的函数 +function varargs(args...) + return args + # 关键字 return 可在函数内部任何地方返回 +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# 省略号 ... 被称为 splat. +# 刚刚用在了函数定义中 +# 还可以用在函数的调用 +# Array 或者 Tuple 的内容会变成参数列表 +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # 获得一个 Array 的 Set +Set([1,2,3]...) # => Set{Int64}(1,2,3) # 相当于 Set(1,2,3) + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # 一个 Tuple 的 Set +Set(x...) # => Set{Int64}(2,3,1) + + +# 可定义可选参数的函数 +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# 还可以定义键值对的参数 +function keyword_args(;k1=4,name2="hello") # note the ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] + +# 可以组合各种类型的参数在同一个函数的参数列表中 +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# prints: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Julia 有一等函数 +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# 这是用 "stabby lambda syntax" 创建的匿名函数 +(x -> x > 2)(3) # => true + +# 这个函数和上面的 create_adder 一模一样 +function create_adder(x) + y -> x + y +end + +# 你也可以给内部函数起个名字 +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# 内置的高阶函数有 +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# 还可以使用 list comprehensions 替代 map +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. 类型 +#################################################### + +# Julia 有类型系统 +# 所有的值都有类型；但变量本身没有类型 +# 你可以用 `typeof` 函数获得值的类型 +typeof(5) # => Int64 + +# 类型是一等值 +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType 是代表类型的类型，也代表他自己的类型 + +# 类型可用作文档化，优化，以及调度 +# 并不是静态检查类型 + +# 用户还可以自定义类型 +# 跟其他语言的 records 或 structs 一样 +# 用 `type` 关键字定义新的类型 + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # 不附带类型标注的相当于 `::Any` +end + +# 构造函数参数是类型的属性 +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# 用新类型作为构造函数还会创建一个类型 +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# struct 类似的类型被称为具体类型 +# 他们可被实例化但不能有子类型 +# 另一种类型是抽象类型 + +# abstract Name +abstract Cat # just a name and point in the type hierarchy + +# 抽象类型不能被实例化，但是可以有子类型 +# 例如，Number 就是抽象类型 +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# 所有的类型都有父类型; 可以用函数 `super` 得到父类型. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# 所有这些类型，除了 Int64, 都是抽象类型. + +# <: 是类型集成操作符 +type Lion <: Cat # Lion 是 Cat 的子类型 + mane_color + roar::String +end + +# 可以继续为你的类型定义构造函数 +# 只需要定义一个同名的函数 +# 并调用已有的构造函数设置一个固定参数 +Lion(roar::String) = Lion("green",roar) +# 这是一个外部构造函数，因为他再类型定义之外 + +type Panther <: Cat # Panther 也是 Cat 的子类型 + eye_color + Panther() = new("green") + # Panthers 只有这个构造函数，没有默认构造函数 +end +# 使用内置构造函数，如 Panther，可以让你控制 +# 如何构造类型的值 +# 应该尽可能使用外部构造函数而不是内部构造函数 + +#################################################### +## 6. 多分派 +#################################################### + +# 在Julia中, 所有的具名函数都是类属函数 +# 这意味着他们都是有很大小方法组成的 +# 每个 Lion 的构造函数都是类属函数 Lion 的方法 + +# 我们来看一个非构造函数的例子 + +# Lion, Panther, Tiger 的 meow 定义为 +function meow(animal::Lion) + animal.roar # 使用点符号访问属性 +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# 试试 meow 函数 +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# 再看看层次结构 +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# 定义一个接收 Cats 的函数 +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => prints "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# 在面向对象语言中，通常都是单分派 +# 这意味着分派方法是通过第一个参数的类型决定的 +# 在Julia中, 所有参数类型都会被考虑到 + +# 让我们定义有多个参数的函数，好看看区别 +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The orange tiger wins! + +# 让我们修改一下传入具体为 Lion 类型时的行为 +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins! + +# 把 Tiger 去掉 +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# 在试试让 Cat 在前面 +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# 警告说明了无法判断使用哪个 fight 方法 +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr +# 结果在老版本 Julia 中可能会不一样 + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie + + +# Under the hood +# 你还可以看看 llvm 以及生成的汇编代码 + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# 给 square_area 一个整形时发生什么 +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prologue + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # Fetch l from memory? + # imul RAX, RAX # Square l and store the result in RAX + # pop RBP # Restore old base pointer + # ret # Result will still be in RAX + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX) + # pop RBP + # ret + # +# 注意 只要参数中又浮点类型，Julia 就使用浮点指令 +# 让我们计算一下圆的面积 +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory + # movabs RAX, 4593140240 # Load pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` diff --git a/zh-cn/livescript-cn.html.markdown b/zh-cn/livescript-cn.html.markdown new file mode 100644 index 00000000..fea00bc1 --- /dev/null +++ b/zh-cn/livescript-cn.html.markdown @@ -0,0 +1,322 @@ +--- +language: LiveScript +filename: learnLivescript.ls +contributors: + - ["Christina Whyte", "http://github.com/kurisuwhyte/"] +translators: + - ["ShengDa Lyu", "http://github.com/SDLyu/"] +lang: zh-cn +--- + +LiveScript 是一种具有函数式特性且编译成 JavaScript 的语言，能对应 JavaScript 的基本语法。 +还有些额外的特性如：柯里化，组合函数，模式匹配，还有借镜于 Haskell，F# 和 Scala 的许多特点。 + +LiveScript 诞生于 [Coco][]，而 Coco 诞生于 [CoffeeScript][]。 +LiveScript 目前已释出稳定版本，开发中的新版本将会加入更多特性。 + +[Coco]: http://satyr.github.io/coco/ +[CoffeeScript]: http://coffeescript.org/ + +非常期待您的反馈，你可以通过 +[@kurisuwhyte](https://twitter.com/kurisuwhyte) 与我连系 :) + + +```coffeescript +# 与 CoffeeScript 一样，LiveScript 使用 # 单行注解。 + +/* + 多行注解与 C 相同。使用注解可以避免被当成 JavaScript 输出。 +*/ +``` +```coffeescript +# 语法的部份，LiveScript 使用缩进取代 {} 来定义区块， +# 使用空白取代 () 来执行函数。 + + +######################################################################## +## 1. 值类型 +######################################################################## + +# `void` 取代 `undefined` 表示未定义的值 +void # 与 `undefined` 等价但更安全（不会被覆写） + +# 空值则表示成 Null。 +null + + +# 最基本的值类型数据是罗辑类型： +true +false + +# 罗辑类型的一些别名，等价于前者： +on; off +yes; no + + +# 数字与 JS 一样，使用倍精度浮点数表示。 +10 +0.4 # 开头的 0 是必要的 + + +# 可以使用底线及单位后缀提高可读性，编译器会自动略过底线及单位后缀。 +12_344km + + +# 字串与 JS 一样，是一种不可变的字元序列： +"Christina" # 单引号也可以！ +"""Multi-line + strings + are + okay + too.""" + +# 在前面加上 \ 符号也可以表示字串： +\keyword # => 'keyword' + + +# 数组是值的有序集合。 +fruits = + * \apple + * \orange + * \pear + +# 可以用 [] 简洁地表示数组： +fruits = [ \apple, \orange, \pear ] + + +# 你可以更方便地建立字串数组，并使用空白区隔元素。 +fruits = <[ apple orange pear ]> + +# 以 0 为起始值的数组下标获取元素： +fruits[0] # => "apple" + + +# 对象是无序键值对集合（更多给节将在下面章节讨论）。 +person = + name: "Christina" + likes: + * "kittens" + * "and other cute stuff" + +# 你也可以用更简洁的方式表示对象： +person = {name: "Christina", likes: ["kittens", "and other cute stuff"]} + +# 可以通过键值获取值： +person.name # => "Christina" +person["name"] # => "Christina" + + +# 正则表达式的使用跟 JavaScript 一样： +trailing-space = /\s$/ # dashed-words 变成 dashedWords + +# 你也可以用多行描述表达式!（注解和空白会被忽略） +funRE = // + function\s+(.+) # name + \s* \((.*)\) \s* # arguments + { (.*) } # body + // + + +######################################################################## +## 2. 基本运算 +######################################################################## + +# 数值操作符与 JavaScript 一样： +1 + 2 # => 3 +2 - 1 # => 1 +2 * 3 # => 6 +4 / 2 # => 2 +3 % 2 # => 1 + + +# 比较操作符大部份也一样，除了 `==` 等价于 JS 中的 `===`， +# JS 中的 `==` 在 LiveScript 里等价于 `~=`， +# `===` 能进行对象、数组和严格比较。 +2 == 2 # => true +2 == "2" # => false +2 ~= "2" # => true +2 === "2" # => false + +[1,2,3] == [1,2,3] # => false +[1,2,3] === [1,2,3] # => true + ++0 == -0 # => true ++0 === -0 # => false + +# 其它关系操作符包括 <、<=、> 和 >= + +# 罗辑值可以通过 `or`、`and` 和 `not` 结合： +true and false # => false +false or true # => true +not false # => true + + +# 集合也有一些便利的操作符 +[1, 2] ++ [3, 4] # => [1, 2, 3, 4] +'a' in <[ a b c ]> # => true +'name' of { name: 'Chris' } # => true + + +######################################################################## +## 3. 函数 +######################################################################## + +# 因为 LiveScript 是函数式特性的语言，你可以期待函数在语言里被高规格的对待。 +add = (left, right) -> left + right +add 1, 2 # => 3 + +# 加上 ! 防止函数执行后的返回值 +two = -> 2 +two! + +# LiveScript 与 JavaScript 一样使用函式作用域，且一样拥有闭包的特性。 +# 与 JavaScript 不同的地方在于，`=` 变量赋值时，左边的对象永远不用变量宣告。 + +# `:=` 操作符允许*重新賦值*父作用域里的变量。 + + +# 你可以解构函数的参数，从不定长度的参数结构里获取感兴趣的值。 +tail = ([head, ...rest]) -> rest +tail [1, 2, 3] # => [2, 3] + +# 你也可以使用一元或二元操作符转换参数。当然也可以预设传入的参数值。 +foo = (a = 1, b = 2) -> a + b +foo! # => 3 + +# 你可以以拷贝的方式传入参数来避免副作用，例如： +copy = (^^target, source) -> + for k,v of source => target[k] = v + target +a = { a: 1 } +copy a, { b: 2 } # => { a: 1, b: 2 } +a # => { a: 1 } + + +# 使用长箭号取代短箭号来柯里化一个函数： +add = (left, right) --> left + right +add1 = add 1 +add1 2 # => 3 + +# 函式里有一个隐式的 `it` 变量，意谓着你不用宣告它。 +identity = -> it +identity 1 # => 1 + +# 操作符在 LiveScript 里不是一個函数，但你可以简单地将它们转换成函数！ +# Enter the operator sectioning： +divide-by-2 = (/ 2) +[2, 4, 8, 16].map(divide-by-2) .reduce (+) + + +# LiveScript 里不只有应用函数，如同其它良好的函数式语言，你可以合并函数获得更多发挥： +double-minus-one = (- 1) . (* 2) + +# 除了普通的数学公式合并 `f . g` 之外，还有 `>>` 和 `<<` 操作符定义函数的合并顺序。 +double-minus-one = (* 2) >> (- 1) +double-minus-one = (- 1) << (* 2) + + +# 说到合并函数的参数, LiveScript 使用 `|>` 和 `<|` 操作符将参数传入： +map = (f, xs) --> xs.map f +[1 2 3] |> map (* 2) # => [2 4 6] + +# 你也可以选择填入值的位置，只需要使用底线 _ 标记： +reduce = (f, xs, initial) --> xs.reduce f, initial +[1 2 3] |> reduce (+), _, 0 # => 6 + + +# 你也能使 _ 让任何函数变成偏函数应用： +div = (left, right) -> left / right +div-by-2 = div _, 2 +div-by-2 4 # => 2 + + +# 最后，也很重要的，LiveScript 拥有後呼叫特性， 可以是基於回调的代码 +# （你可以试试其它函数式特性的解法，比如 Promises）： +readFile = (name, f) -> f name +a <- readFile 'foo' +b <- readFile 'bar' +console.log a + b + +# 等同於： +readFile 'foo', (a) -> readFile 'bar', (b) -> console.log a + b + + +######################################################################## +## 4. 模式、判断和流程控制 +######################################################################## + +# 流程控制可以使用 `if...else` 表达式： +x = if n > 0 then \positive else \negative + +# 除了 `then` 你也可以使用 `=>` +x = if n > 0 => \positive + else \negative + +# 过於复杂的流程可以用 `switch` 表达式代替： +y = {} +x = switch + | (typeof y) is \number => \number + | (typeof y) is \string => \string + | 'length' of y => \array + | otherwise => \object # `otherwise` 和 `_` 是等价的。 + +# 函数主体、宣告式和赋值式可以表式成 `switch`，这可以省去一些代码： +take = (n, [x, ...xs]) --> + | n == 0 => [] + | _ => [x] ++ take (n - 1), xs + + +######################################################################## +## 5. 推导式 +######################################################################## + +# 在 JavaScript 的标准函式库里有一些辅助函数能帮助处理列表及对象 +#（LiveScript 则带有一个 prelude.ls ，作为标准函式库的补充 ）， +# 推导式能让你使用优雅的语法且快速地处理这些事： +oneToTwenty = [1 to 20] +evens = [x for x in oneToTwenty when x % 2 == 0] + +# 在推导式里 `when` 和 `unless` 可以当成过滤器使用。 + +# 对象推导式在使用上也是同样的方式，差别在于你使用的是对象而不是数组： +copy = { [k, v] for k, v of source } + + +######################################################################## +## 6. OOP +######################################################################## + +# 虽然 LiveScript 是一门函数式语言，但具有一些命令式及面向对象的特性。 +# 像是 class 语法和一些借镜於 CoffeeScript 的类别继承语法糖： +class Animal + (@name, kind) -> + @kind = kind + action: (what) -> "*#{@name} (a #{@kind}) #{what}*" + +class Cat extends Animal + (@name) -> super @name, 'cat' + purr: -> @action 'purrs' + +kitten = new Cat 'Mei' +kitten.purr! # => "*Mei (a cat) purrs*" + +# 除了类别的单一继承模式之外，还提供了像混入 (Mixins) 这种特性。 +# Mixins 在语言里被当成普通对象： +Huggable = + hug: -> @action 'is hugged' + +class SnugglyCat extends Cat implements Huggable + +kitten = new SnugglyCat 'Purr' +kitten.hug! # => "*Mei (a cat) is hugged*" +``` + +## 延伸阅读 + +LiveScript 还有许多强大之处，但这些应该足够启发你写些小型函数式程式了。 +[LiveScript](http://livescript.net/)有更多关于 LiveScript 的资讯 +和线上编译器等着你来试！ + +你也可以参考 +[prelude.ls](http://gkz.github.io/prelude-ls/)，和一些 `#livescript` +的网络聊天室频道。 diff --git a/zh-cn/lua-cn.html.markdown b/zh-cn/lua-cn.html.markdown new file mode 100644 index 00000000..098d0ab5 --- /dev/null +++ b/zh-cn/lua-cn.html.markdown @@ -0,0 +1,414 @@ +--- +language: Lua +lang: zh-cn +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] + - ["Rob Hoelz", "http://hoelz.ro"] + - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Craig Roddin", "craig.roddin@gmail.com"] + - ["Amr Tamimi", "https://amrtamimi.com"] +translators: + - ["Jakukyo Friel", "http://weakish.github.io"] +filename: lua-cn.lua +--- + +```lua +-- 单行注释以两个连字符开头 + +--[[ + 多行注释 +--]] + +---------------------------------------------------- +-- 1. 变量和流程控制 +---------------------------------------------------- + +num = 42 -- 所有的数字都是双精度浮点型。 +-- 别害怕，64位的双精度浮点型数字中有52位用于 +-- 保存精确的整型值; 对于52位以内的整型值， +-- 不用担心精度问题。 + +s = 'walternate' -- 和Python一样，字符串不可变。 +t = "也可以用双引号" +u = [[ 多行的字符串 + 以两个方括号 + 开始和结尾。]] +t = nil -- 撤销t的定义; Lua 支持垃圾回收。 + +-- 块使用do/end之类的关键字标识： +while num < 50 do + num = num + 1 -- 不支持 ++ 或 += 运算符。 +end + +-- If语句： +if num > 40 then + print('over 40') +elseif s ~= 'walternate' then -- ~= 表示不等于。 + -- 像Python一样，用 == 检查是否相等 ；字符串同样适用。 + io.write('not over 40\n') -- 默认标准输出。 +else + -- 默认全局变量。 + thisIsGlobal = 5 -- 通常使用驼峰。 + + -- 如何定义局部变量： + local line = io.read() -- 读取标准输入的下一行。 + + -- ..操作符用于连接字符串： + print('Winter is coming, ' .. line) +end + +-- 未定义的变量返回nil。 +-- 这不是错误： +foo = anUnknownVariable -- 现在 foo = nil. + +aBoolValue = false + +--只有nil和false为假; 0和 ''均为真！ +if not aBoolValue then print('false') end + +-- 'or'和 'and'短路 +-- 类似于C/js里的 a?b:c 操作符： +ans = aBoolValue and 'yes' or 'no' --> 'no' + +karlSum = 0 +for i = 1, 100 do -- 范围包含两端 + karlSum = karlSum + i +end + +-- 使用 "100, 1, -1" 表示递减的范围： +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- 通常，范围表达式为begin, end[, step]. + +-- 循环的另一种结构： +repeat + print('the way of the future') + num = num - 1 +until num == 0 + +---------------------------------------------------- +-- 2. 函数。 +---------------------------------------------------- + +function fib(n) + if n < 2 then return 1 end + return fib(n - 2) + fib(n - 1) +end + +-- 支持闭包及匿名函数： +function adder(x) + -- 调用adder时，会创建返回的函数， + -- 并且会记住x的值： + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- 返回值、函数调用和赋值都可以 +-- 使用长度不匹配的list。 +-- 不匹配的接收方会被赋值nil； +-- 不匹配的发送方会被丢弃。 + +x, y, z = 1, 2, 3, 4 +-- x = 1、y = 2、z = 3, 而 4 会被丢弃。 + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> 打印 "zaphod nil nil" +-- 现在 x = 4, y = 8, 而值15..42被丢弃。 + +-- 函数是一等公民，可以是局部的，也可以是全局的。 +-- 以下表达式等价： +function f(x) return x * x end +f = function (x) return x * x end + +-- 这些也是等价的： +local function g(x) return math.sin(x) end +local g; g = function (x) return math.sin(x) end +-- 'local g'使得g可以自引用。 + +-- 顺便提下，三角函数以弧度为单位。 + +-- 用一个字符串参数调用函数，可以省略括号： +print 'hello' --可以工作。 + +-- 调用函数时，如果只有一个table参数， +-- 同样可以省略括号（table详情见下）： +print {} -- 一样可以工作。 + +---------------------------------------------------- +-- 3. Table。 +---------------------------------------------------- + +-- Table = Lua唯一的组合数据结构; +-- 它们是关联数组。 +-- 类似于PHP的数组或者js的对象， +-- 它们是哈希表或者字典，也可以当列表使用。 + +-- 按字典/map的方式使用Table： + +-- Dict字面量默认使用字符串类型的key： +t = {key1 = 'value1', key2 = false} + +-- 字符串key可以使用类似js的点标记： +print(t.key1) -- 打印 'value1'. +t.newKey = {} -- 添加新的键值对。 +t.key2 = nil -- 从table删除 key2。 + +-- 使用任何非nil的值作为key： +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- 打印 "tau" + +-- 数字和字符串的key按值匹配的 +-- table按id匹配。 +a = u['@!#'] -- 现在 a = 'qbert'. +b = u[{}] -- 我们或许期待的是 1729, 但是得到的是nil: +-- b = nil ，因为没有找到。 +-- 之所以没找到，是因为我们用的key与保存数据时用的不是同 +-- 一个对象。 +-- 所以字符串和数字是移植性更好的key。 + +-- 只需要一个table参数的函数调用不需要括号： +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- 打印'Sonmi~451'. + +for key, val in pairs(u) do -- 遍历Table + print(key, val) +end + +-- _G 是一个特殊的table，用于保存所有的全局变量 +print(_G['_G'] == _G) -- 打印'true'. + +-- 按列表/数组的方式使用： + +-- 列表字面量隐式添加整数键： +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v 是列表的大小 + print(v[i]) -- 索引从 1 开始!! 太疯狂了！ +end +-- 'list'并非真正的类型，v 其实是一个table， +-- 只不过它用连续的整数作为key，可以像list那样去使用。 + +---------------------------------------------------- +-- 3.1 元表（metatable） 和元方法（metamethod）。 +---------------------------------------------------- + +-- table的元表提供了一种机制，支持类似操作符重载的行为。 +-- 稍后我们会看到元表如何支持类似js prototype的行为。 + +f1 = {a = 1, b = 2} -- 表示一个分数 a/b. +f2 = {a = 2, b = 3} + +-- 这会失败： +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- 调用在f1的元表上的__add(f1, f2) 方法 + +-- f1, f2 没有关于元表的key，这点和js的prototype不一样。 +-- 因此你必须用getmetatable(f1)获取元表。 +-- 元表是一个普通的table， +-- 元表的key是普通的Lua中的key，例如__add。 + +-- 但是下面一行代码会失败，因为s没有元表： +-- t = s + s +-- 下面提供的与类相似的模式可以解决这个问题： + +-- 元表的__index 可以重载用于查找的点操作符： +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- 可以工作！感谢元表 + +-- 如果在table中直接查找key失败，会使用 +-- 元表的__index 递归地重试。 + +-- __index的值也可以是function(tbl, key) +-- 这样可以支持自定义查找。 + +-- __index、__add等的值，被称为元方法。 +-- 这里是一个table元方法的清单： + +-- __add(a, b) for a + b +-- __sub(a, b) for a - b +-- __mul(a, b) for a * b +-- __div(a, b) for a / b +-- __mod(a, b) for a % b +-- __pow(a, b) for a ^ b +-- __unm(a) for -a +-- __concat(a, b) for a .. b +-- __len(a) for #a +-- __eq(a, b) for a == b +-- __lt(a, b) for a < b +-- __le(a, b) for a <= b +-- __index(a, b) <fn or a table> for a.b +-- __newindex(a, b, c) for a.b = c +-- __call(a, ...) for a(...) + +---------------------------------------------------- +-- 3.2 与类相似的table和继承。 +---------------------------------------------------- + +-- Lua没有内建的类；可以通过不同的方法，利用表和元表 +-- 来实现类。 + +-- 下面是一个例子，解释在后面： + +Dog = {} -- 1. + +function Dog:new() -- 2. + newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('I say ' .. self.sound) +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'I say woof' -- 8. + +-- 1. Dog看上去像一个类；其实它是一个table。 +-- 2. 函数tablename:fn(...) 等价于 +-- 函数tablename.fn(self, ...) +-- 冒号（:）只是添加了self作为第一个参数。 +-- 阅读7 & 8条 了解self变量是如何得到其值的。 +-- 3. newObj是类Dog的一个实例。 +-- 4. self = 被继承的类。通常self = Dog，不过继承可以改变它。 +-- 如果把newObj的元表和__index都设置为self， +-- newObj就可以得到self的函数。 +-- 5. 备忘：setmetatable返回其第一个参数。 +-- 6. 冒号（：）的作用和第2条一样，不过这里 +-- self是一个实例，而不是类 +-- 7. 等价于Dog.new(Dog)，所以在new()中，self = Dog。 +-- 8. 等价于mrDog.makeSound(mrDog); self = mrDog。 + +---------------------------------------------------- + +-- 继承的例子： + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + s = self.sound .. ' ' -- 2. + print(s .. s .. s) +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof' -- 4. + +-- 1. LoudDog获得Dog的方法和变量列表。 +-- 2. 因为new()的缘故，self拥有了一个'sound' key，参见第3条。 +-- 3. 等价于LoudDog.new(LoudDog)，转换一下就是 +-- Dog.new(LoudDog)，这是因为LoudDog没有'new' key， +-- 但是它的元表中有 __index = Dog。 +-- 结果: seymour的元表是LoudDog，并且 +-- LoudDog.__index = Dog。所以有seymour.key +-- = seymour.key, LoudDog.key, Dog.key +-- 从其中第一个有指定key的table获取。 +-- 4. 在LoudDog可以找到'makeSound'的key； +-- 等价于LoudDog.makeSound(seymour)。 + +-- 如果有必要，子类也可以有new()，与基类相似： +function LoudDog:new() + newObj = {} + -- 初始化newObj + self.__index = self + return setmetatable(newObj, self) +end + +---------------------------------------------------- +-- 4. 模块 +---------------------------------------------------- + + +--[[ 我把这部分给注释了，这样脚本剩下的部分可以运行 + +-- 假设文件mod.lua的内容类似这样： +local M = {} + +local function sayMyName() + print('Hrunkner') +end + +function M.sayHello() + print('Why hello there') + sayMyName() +end + +return M + +-- 另一个文件可以使用mod.lua的功能： +local mod = require('mod') -- 运行文件mod.lua. + +-- require是包含模块的标准做法。 +-- require等价于: (针对没有被缓存的情况；参见后面的内容) +local mod = (function () + <contents of mod.lua> +end)() +-- mod.lua被包在一个函数体中，因此mod.lua的局部变量 +-- 对外不可见。 + +-- 下面的代码可以工作，因为在这里mod = mod.lua 中的 M： +mod.sayHello() -- Says hello to Hrunkner. + +-- 这是错误的；sayMyName只在mod.lua中存在： +mod.sayMyName() -- 错误 + +-- require返回的值会被缓存，所以一个文件只会被运行一次， +-- 即使它被require了多次。 + +-- 假设mod2.lua包含代码"print('Hi!')"。 +local a = require('mod2') -- 打印Hi! +local b = require('mod2') -- 不再打印; a=b. + +-- dofile与require类似，但是不缓存： +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (再次运行，与require不同) + +-- loadfile加载一个lua文件，但是并不运行它。 +f = loadfile('mod2') -- Calling f() runs mod2.lua. + +-- loadstring是loadfile的字符串版本。 +g = loadstring('print(343)') --返回一个函数。 +g() -- 打印343; 在此之前什么也不打印。 + +--]] +``` + +## 参考 + + + +为什么？我非常兴奋地学习lua， 这样我就可以使用[Löve 2D游戏引擎](http://love2d.org/)来编游戏。 + +怎么做？我从[BlackBulletIV的面向程序员的Lua指南](http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/)入门。接着我阅读了官方的[Lua编程](http://www.lua.org/pil/contents.html)一书。 + +lua-users.org上的[Lua简明参考](http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf)应该值得一看。 + +本文没有涉及标准库的内容： + +* <a href="http://lua-users.org/wiki/StringLibraryTutorial">string library</a> +* <a href="http://lua-users.org/wiki/TableLibraryTutorial">table library</a> +* <a href="http://lua-users.org/wiki/MathLibraryTutorial">math library</a> +* <a href="http://lua-users.org/wiki/IoLibraryTutorial">io library</a> +* <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a> + +使用Lua，欢乐常在！ diff --git a/zh-cn/markdown-cn.html.markdown b/zh-cn/markdown-cn.html.markdown new file mode 100644 index 00000000..b633714d --- /dev/null +++ b/zh-cn/markdown-cn.html.markdown @@ -0,0 +1,240 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators: + - ["Fangzhou Chen","https://github.com/FZSS"] +filename: learnmarkdown-cn.md +lang: zh-cn +--- + +Markdown 由 John Gruber 于 2004年创立. 它旨在成为一门容易读写的语法结构，并可以便利地转换成 HTML（以及其他很多）格式。 + +欢迎您多多反馈以及分支和请求合并。 + + +```markdown +<!-- Markdown 是 HTML 的父集，所以任何 HTML 文件都是有效的 Markdown。 +这意味着我们可以在 Markdown 里使用任何 HTML 元素，比如注释元素， +且不会被 Markdown 解析器所影响。不过如果你在 Markdown 文件内创建了 HTML 元素， +你将无法在 HTML 元素的内容中使用 Markdown 语法。--> + +<!-- 在不同的解析器中，Markdown 的实现方法有所不同。 +此教程会指出当某功能是否通用及是否只对某一解析器有效。 --> + +<!-- 标头 --> +<!-- 通过在文本前加上不同数量的hash(#), 你可以创建相对应的 <h1> +到 <h6> HTML元素。--> + +# 这是一个 <h1> +## 这是一个 <h2> +### 这是一个 <h3> +#### 这是一个 <h4> +##### 这是一个 <h5> +###### 这是一个 <h6> + +<!-- 对于 <h1> 和 <h2> 元素，Markdown 额外提供了两种添加方式。 --> +这是一个 h1 +============= + +这是一个 h2 +------------- + +<!-- 简易文本样式 --> +<!-- 文本的斜体，粗体，和删除线在 Markdown 中可以轻易地被实现。--> + +*此文本为斜体。* +_此文本也是。_ + +**此文本为粗体。** +__此文本也是__ + +***此文本是斜体加粗体。*** +**_或者这样。_** +*__这个也是！__* + +<!-- 在 Github 采用的 Markdown 中 --> + +~~此文本为删除线效果。~~ + +<!-- 单个段落由一句或多句邻近的句子组成，这些句子由一个或多个空格分隔。--> + +这是第一段落. 这句话在同一个段落里，好玩么？ + +现在我是第二段落。 +这句话也在第二段落！ + +这句话在第三段落！ + +<!-- 如果你插入一个 HTML中的<br />标签，你可以在段末加入两个以上的空格， +然后另起一段。--> + +此段落结尾有两个空格（选中以显示）。 + +上文有一个 <br /> ！ + +<!-- 段落引用可由 > 字符轻松实现。--> + +> 这是一个段落引用. 你可以 +> 手动断开你的句子，然后在每句句子前面添加 “>” 字符。或者让你的句子变得很长，以至于他们自动得断开。 +> 只要你的文字以“>” 字符开头，两种方式无异。 + +> 你也对文本进行 +>> 多层引用 +> 这多机智啊！ + +<!-- 序列 --> +<!-- 无序序列可由星号，加号或者减号来建立 --> + +* 项目 +* 项目 +* 另一个项目 + +或者 + ++ 项目 ++ 项目 ++ 另一个项目 + +或者 + +- 项目 +- 项目 +- 最后一个项目 + +<!-- 有序序列可由数字加点来实现 --> + +1. 项目一 +2. 项目二 +3. 项目三 + +<!-- 即使你的标签数字有误，Markdown 依旧会呈现出正确的序号， +不过这并不是一个好主意--> + +1. 项目一 +1. 项目二 +1. 项目三 +<!-- (此段与前例一模一样) --> + +<!-- 你也可以使用子序列 --> + +1. 项目一 +2. 项目二 +3. 项目三 + * 子项目 + * 子项目 +4. 项目四 + +<!-- 代码段落 --> +<!-- 代码段落（HTML中 <code>标签）可以由缩进四格（spaces） +或者一个制表符（tab）实现--> + + This is code + So is this + +<!-- 在你的代码中，你仍然使用tab可以进行缩进操作 --> + + my_array.each do |item| + puts item + end + +<!-- 内联代码可由反引号 ` 实现 --> + +John 甚至不知道 `go_to()` 方程是干嘛的! + +<!-- 在Github的 Markdown中，对于代码你可以使用特殊的语法 --> + +\`\`\`ruby <!-- 插入时记得移除反斜线， 仅留```ruby ！ --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- 这里也是，移除反斜线，仅留 ``` --> + +<!-- 以上代码不需要缩进，而且 Github 会根据```后表明的语言来进行语法高亮 --> + +<!-- 水平线 （<hr />） --> +<!-- 水平线可由三个或以上的星号或者减号创建，可带可不带空格。 --> + +*** +--- +- - - +**************** + +<!-- 链接 --> +<!-- Markdown 最棒的地方就是简易的链接制作。链接文字放在中括号[]内， +在随后的括弧()内加入url。--> + +[点我点我!](http://test.com/) + +<!-- 你也可以为链接加入一个标题：在括弧内使用引号 --> + +[点我点我!](http://test.com/ "连接到Test.com") + +<!-- 相对路径也可以有 --> + +[去 music](/music/). + +<!-- Markdown同样支持引用样式的链接 --> + +[点此链接][link1]以获取更多信息！ +[看一看这个链接][foobar] 如果你愿意的话. + +[link1]: http://test.com/ "Cool!" +[foobar]: http://foobar.biz/ "Alright!" + +<!-- 链接的标题可以处于单引号中，括弧中或是被忽略。引用名可以在文档的任意何处， +并且可以随意命名，只要名称不重复。--> + +<!-- “隐含式命名” 的功能可以让链接文字作为引用名 --> + +[This][] is a link. + +[this]: http://thisisalink.com/ + +<!-- 但这并不常用 --> + +<!-- 图像 --> +<!-- 图像与链接相似，只需在前添加一个感叹号 --> + + + +<!-- 引用样式也同样起作用 --> + +![这是我的悬停文本.][myimage] + +[myimage]: relative/urls/cool/image.jpg "在此输入标题" + +<!-- 杂项 --> +<!-- 自动链接 --> + +<http://testwebsite.com/> 与 +[http://testwebsite.com/](http://testwebsite.com/) 等同 + +<!-- 电子邮件的自动链接 --> + +<foo@bar.com> + +<!-- 转义字符 --> + +我希望 *将这段文字置于星号之间* 但是我不希望它被 +斜体化, 所以我就: \*这段置文字于星号之间\*。 + +<!-- 表格 --> +<!-- 表格只被 Github 的 Markdown 支持，并且有一点笨重，但如果你真的要用的话: --> + +| 第一列 | 第二列 | 第三列 | +| :---------- | :------: | ----------: | +| 左对齐 | 居个中 | 右对齐 | +| 某某某 | 某某某 | 某某某 | + +<!-- 或者, 同样的 --> + +第一列 | 第二列 | 第三列 +:-- | :-: | --: +这太丑了 | 药不能 | 停 + +<!-- 结束! --> + +``` + +更多信息, 请于[此处](http://daringfireball.net/projects/Markdown/syntax)参见 John Gruber 关于语法的官方帖子，及于[此处](https://github.com/adam-p/Markdown-here/wiki/Markdown-Cheatsheet) 参见 Adam Pritchard 的摘要笔记。 diff --git a/zh-cn/matlab-cn.html.markdown b/zh-cn/matlab-cn.html.markdown new file mode 100644 index 00000000..77ba765a --- /dev/null +++ b/zh-cn/matlab-cn.html.markdown @@ -0,0 +1,491 @@ +---
+language: Matlab
+contributors:
+ - ["mendozao", "http://github.com/mendozao"]
+ - ["jamesscottbrown", "http://jamesscottbrown.com"]
+translators:
+ - ["sunxb10", "https://github.com/sunxb10"]
+lang: zh-cn
+---
+
+MATLAB 是 MATrix LABoratory （矩阵实验室）的缩写，它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。
+
+如果您有任何需要反馈或交流的内容，请联系本教程作者[@the_ozzinator](https://twitter.com/the_ozzinator)、[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。
+
+```matlab
+% 以百分号作为注释符
+
+%{
+多行注释
+可以
+这样
+表示
+%}
+
+% 指令可以随意跨行，但需要在跨行处用 '...' 标明：
+ a = 1 + 2 + ...
+ + 4
+
+% 可以在MATLAB中直接向操作系统发出指令
+!ping google.com
+
+who % 显示内存中的所有变量
+whos % 显示内存中的所有变量以及它们的类型
+clear % 清除内存中的所有变量
+clear('A') % 清除指定的变量
+openvar('A') % 在变量编辑器中编辑指定变量
+
+clc % 清除命令窗口中显示的所有指令
+diary % 将命令窗口中的内容写入本地文件
+ctrl-c % 终止当前计算
+
+edit('myfunction.m') % 在编辑器中打开指定函数或脚本
+type('myfunction.m') % 在命令窗口中打印指定函数或脚本的源码
+
+profile on % 打开 profile 代码分析工具
+profile of % 关闭 profile 代码分析工具
+profile viewer % 查看 profile 代码分析工具的分析结果
+
+help command % 在命令窗口中显示指定命令的帮助文档
+doc command % 在帮助窗口中显示指定命令的帮助文档
+lookfor command % 在所有 MATLAB 内置函数的头部注释块的第一行中搜索指定命令
+lookfor command -all % 在所有 MATLAB 内置函数的整个头部注释块中搜索指定命令
+
+
+% 输出格式
+format short % 浮点数保留 4 位小数
+format long % 浮点数保留 15 位小数
+format bank % 金融格式，浮点数只保留 2 位小数
+fprintf('text') % 在命令窗口中显示 "text"
+disp('text') % 在命令窗口中显示 "text"
+
+
+% 变量与表达式
+myVariable = 4 % 命令窗口中将新创建的变量
+myVariable = 4; % 加上分号可使命令窗口中不显示当前语句执行结果
+4 + 6 % ans = 10
+8 * myVariable % ans = 32
+2 ^ 3 % ans = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+
+% 调用函数有两种方式：
+% 标准函数语法：
+load('myFile.mat', 'y') % 参数放在括号内，以英文逗号分隔
+% 指令语法:
+load myFile.mat y % 不加括号，以空格分隔参数
+% 注意在指令语法中参数不需要加引号：在这种语法下，所有输入参数都只能是文本文字，
+% 不能是变量的具体值，同样也不能是输出变量
+[V,D] = eig(A); % 这条函数调用无法转换成等价的指令语法
+[~,D] = eig(A); % 如果结果中只需要 D 而不需要 V 则可以这样写
+
+
+
+% 逻辑运算
+1 > 5 % 假，ans = 0
+10 >= 10 % 真，ans = 1
+3 ~= 4 % 不等于 -> ans = 1
+3 == 3 % 等于 -> ans = 1
+3 > 1 && 4 > 1 % 与 -> ans = 1
+3 > 1 || 4 > 1 % 或 -> ans = 1
+~1 % 非 -> ans = 0
+
+% 逻辑运算可直接应用于矩阵，运算结果也是矩阵
+A > 5
+% 对矩阵中每个元素做逻辑运算，若为真，则在运算结果的矩阵中对应位置的元素就是 1
+A( A > 5 )
+% 如此返回的向量，其元素就是 A 矩阵中所有逻辑运算为真的元素
+
+% 字符串
+a = 'MyString'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MyStringMyString
+b = '字符串' % MATLAB目前已经可以支持包括中文在内的多种文字
+length(b) % ans = 3
+b(2) % ans = 符
+[b,b] % ans = 字符串字符串
+
+
+% 元组（cell 数组）
+a = {'one', 'two', 'three'}
+a(1) % ans = 'one' - 返回一个元组
+char(a(1)) % ans = one - 返回一个字符串
+
+
+% 结构体
+A.b = {'one','two'};
+A.c = [1 2];
+A.d.e = false;
+
+
+% 向量
+x = [4 32 53 7 1]
+x(2) % ans = 32，MATLAB中向量的下标索引从1开始，不是0
+x(2:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % 列向量
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+
+% 矩阵
+A = [1 2 3; 4 5 6; 7 8 9]
+% 以分号分隔不同的行，以空格或逗号分隔同一行中的不同元素
+% A =
+
+% 1 2 3
+% 4 5 6
+% 7 8 9
+
+A(2,3) % ans = 6，A(row, column)
+A(6) % ans = 8
+% （隐式地将 A 的三列首尾相接组成一个列向量，然后取其下标为 6 的元素）
+
+
+A(2,3) = 42 % 将第 2 行第 3 列的元素设为 42
+% A =
+
+% 1 2 3
+% 4 5 42
+% 7 8 9
+
+A(2:3,2:3) % 取原矩阵中的一块作为新矩阵
+%ans =
+
+% 5 42
+% 8 9
+
+A(:,1) % 第 1 列的所有元素
+%ans =
+
+% 1
+% 4
+% 7
+
+A(1,:) % 第 1 行的所有元素
+%ans =
+
+% 1 2 3
+
+[A ; A] % 将两个矩阵上下相接构成新矩阵
+%ans =
+
+% 1 2 3
+% 4 5 42
+% 7 8 9
+% 1 2 3
+% 4 5 42
+% 7 8 9
+
+% 等价于
+vertcat(A, A);
+
+
+[A , A] % 将两个矩阵左右相接构成新矩阵
+
+%ans =
+
+% 1 2 3 1 2 3
+% 4 5 42 4 5 42
+% 7 8 9 7 8 9
+
+% 等价于
+horzcat(A, A);
+
+
+A(:, [3 1 2]) % 重新排布原矩阵的各列
+%ans =
+
+% 3 1 2
+% 42 4 5
+% 9 7 8
+
+size(A) % 返回矩阵的行数和列数，ans = 3 3
+
+A(1, :) =[] % 删除矩阵的第 1 行
+A(:, 1) =[] % 删除矩阵的第 1 列
+
+transpose(A) % 矩阵转置，等价于 A'
+ctranspose(A) % 矩阵的共轭转置（对矩阵中的每个元素取共轭复数）
+
+
+% 元素运算 vs. 矩阵运算
+% 单独运算符就是对矩阵整体进行矩阵运算
+% 在运算符加上英文句点就是对矩阵中的元素进行元素计算
+% 示例如下：
+A * B % 矩阵乘法，要求 A 的列数等于 B 的行数
+A .* B % 元素乘法，要求 A 和 B 形状一致（A 的行数等于 B 的行数， A 的列数等于 B 的列数）
+% 元素乘法的结果是与 A 和 B 形状一致的矩阵，其每个元素等于 A 对应位置的元素乘 B 对应位置的元素
+
+% 以下函数中，函数名以 m 结尾的执行矩阵运算，其余执行元素运算：
+exp(A) % 对矩阵中每个元素做指数运算
+expm(A) % 对矩阵整体做指数运算
+sqrt(A) % 对矩阵中每个元素做开方运算
+sqrtm(A) % 对矩阵整体做开放运算（即试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）
+
+
+% 绘图
+x = 0:.10:2*pi; % 生成一向量，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi（pi 就是圆周率）
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x 轴范围是从 0 到 2*pi，y 轴范围是从 -1 到 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % 在同一张图中绘制多条曲线
+legend('Line 1 label', 'Line 2 label') % 为图片加注图例
+% 图例数量应当小于或等于实际绘制的曲线数目，从 plot 绘制的第一条曲线开始对应
+
+% 在同一张图上绘制多条曲线的另一种方法：
+% 使用 hold on，令系统保留前次绘图结果并在其上直接叠加新的曲线，
+% 如果没有 hold on，则每个 plot 都会首先清除之前的绘图结果再进行绘制。
+% 在 hold on 和 hold off 中可以放置任意多的 plot 指令，
+% 它们和 hold on 前最后一个 plot 指令的结果都将显示在同一张图中。
+plot(x, y1)
+hold on
+plot(x, y2)
+plot(x, y3)
+plot(x, y4)
+hold off
+
+loglog(x, y) % 对数—对数绘图
+semilogx(x, y) % 半对数（x 轴对数）绘图
+semilogy(x, y) % 半对数（y 轴对数）绘图
+
+fplot (@(x) x^2, [2,5]) % 绘制函数 x^2 在 [2, 5] 区间的曲线
+
+grid on % 在绘制的图中显示网格，使用 grid off 可取消网格显示
+axis square % 将当前坐标系设定为正方形（保证在图形显示上各轴等长）
+axis equal % 将当前坐标系设定为相等（保证在实际数值上各轴等长）
+
+scatter(x, y); % 散点图
+hist(x); % 直方图
+
+z = sin(x);
+plot3(x,y,z); % 绘制三维曲线
+
+pcolor(A) % 伪彩色图（热图）
+contour(A) % 等高线图
+mesh(A) % 网格曲面图
+
+h = figure % 创建新的图片对象并返回其句柄 h
+figure(h) % 将句柄 h 对应的图片作为当前图片
+close(h) % 关闭句柄 h 对应的图片
+close all % 关闭 MATLAB 中所用打开的图片
+close % 关闭当前图片
+
+shg % 显示图形窗口
+clf clear % 清除图形窗口中的图像，并重置图像属性
+
+% 图像属性可以通过图像句柄进行设定
+% 在创建图像时可以保存图像句柄以便于设置
+% 也可以用 gcf 函数返回当前图像的句柄
+h = plot(x, y); % 在创建图像时显式地保存图像句柄
+set(h, 'Color', 'r')
+% 颜色代码：'y' 黄色，'m' 洋红色，'c' 青色，'r' 红色，'g' 绿色，'b' 蓝色，'w' 白色，'k' 黑色
+set(h, 'Color', [0.5, 0.5, 0.4])
+% 也可以使用 RGB 值指定颜色
+set(h, 'LineStyle', '--')
+% 线型代码：'--' 实线，'---' 虚线，':' 点线，'-.' 点划线，'none' 不划线
+get(h, 'LineStyle')
+% 获取当前句柄的线型
+
+
+% 用 gca 函数返回当前图像的坐标轴句柄
+set(gca, 'XDir', 'reverse'); % 令 x 轴反向
+
+% 用 subplot 指令创建平铺排列的多张子图
+subplot(2,3,1); % 选择 2 x 3 排列的子图中的第 1 张图
+plot(x1); title('First Plot') % 在选中的图中绘图
+subplot(2,3,2); % 选择 2 x 3 排列的子图中的第 2 张图
+plot(x2); title('Second Plot') % 在选中的图中绘图
+
+
+% 要调用函数或脚本，必须保证它们在你的当前工作目录中
+path % 显示当前工作目录
+addpath /path/to/dir % 将指定路径加入到当前工作目录中
+rmpath /path/to/dir % 将指定路径从当前工作目录中删除
+cd /path/to/move/into % 以制定路径作为当前工作目录
+
+
+% 变量可保存到 .mat 格式的本地文件
+save('myFileName.mat') % 保存当前工作空间中的所有变量
+load('myFileName.mat') % 将指定文件中的变量载入到当前工作空间
+
+
+% .m 脚本文件
+% 脚本文件是一个包含多条 MATLAB 指令的外部文件，以 .m 为后缀名
+% 使用脚本文件可以避免在命令窗口中重复输入冗长的指令
+
+
+% .m 函数文件
+% 与脚本文件类似，同样以 .m 作为后缀名
+% 但函数文件可以接受用户输入的参数并返回运算结果
+% 并且函数拥有自己的工作空间（变量域），不必担心变量名称冲突
+% 函数文件的名称应当与其所定义的函数的名称一致（比如下面例子中函数文件就应命名为 double_input.m）
+% 使用 'help double_input.m' 可返回函数定义中第一行注释信息
+function output = double_input(x)
+ % double_input(x) 返回 x 的 2 倍
+ output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% 同样还可以定义子函数和内嵌函数
+% 子函数与主函数放在同一个函数文件中，且只能被这个主函数调用
+% 内嵌函数放在另一个函数体内，可以直接访问被嵌套函数的各个变量
+
+
+% 使用匿名函数可以不必创建 .m 函数文件
+% 匿名函数适用于快速定义某函数以便传递给另一指令或函数（如绘图、积分、求根、求极值等）
+% 下面示例的匿名函数返回输入参数的平方根，可以使用句柄 sqr 进行调用：
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % find out more
+
+
+% 接受用户输入
+a = input('Enter the value: ')
+
+
+% 从文件中读取数据
+fopen(filename)
+% 类似函数还有 xlsread（excel 文件）、importdata（CSV 文件）、imread（图像文件）
+
+
+% 输出
+disp(a) % 在命令窗口中打印变量 a 的值
+disp('Hello World') % 在命令窗口中打印字符串
+fprintf % 按照指定格式在命令窗口中打印内容
+
+% 条件语句（if 和 elseif 语句中的括号并非必需，但推荐加括号避免混淆）
+if (a > 15)
+ disp('Greater than 15')
+elseif (a == 23)
+ disp('a is 23')
+else
+ disp('neither condition met')
+end
+
+% 循环语句
+% 注意：对向量或矩阵使用循环语句进行元素遍历的效率很低！！
+% 注意：只要有可能，就尽量使用向量或矩阵的整体运算取代逐元素循环遍历！！
+% MATLAB 在开发时对向量和矩阵运算做了专门优化，做向量和矩阵整体运算的效率高于循环语句
+for k = 1:5
+ disp(k)
+end
+
+k = 0;
+while (k < 5)
+ k = k + 1;
+end
+
+
+% 程序运行计时：'tic' 是计时开始，'toc' 是计时结束并打印结果
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+
+% 链接 MySQL 数据库
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); % 此处 xx 代表具体版本号
+% 这里的 mysql-connector-java-5.1.xx-bin.jar 可从 http://dev.mysql.com/downloads/connector/j/ 下载
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % SQL 语句
+a = fetch(conn, sql) % a 即包含所需数据
+
+
+% 常用数学函数
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x)
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % 均匀分布的伪随机浮点数
+randi % 均匀分布的伪随机整数
+randn % 正态分布的伪随机浮点数
+
+% 常用常数
+pi
+NaN
+inf
+
+% 求解矩阵方程（如果方程无解，则返回最小二乘近似解）
+% \ 操作符等价于 mldivide 函数，/ 操作符等价于 mrdivide 函数
+x=A\b % 求解 Ax=b，比先求逆再左乘 inv(A)*b 更加高效、准确
+x=b/A % 求解 xA=b
+
+inv(A) % 逆矩阵
+pinv(A) % 伪逆矩阵
+
+
+% 常用矩阵函数
+zeros(m, n) % m x n 阶矩阵，元素全为 0
+ones(m, n) % m x n 阶矩阵，元素全为 1
+diag(A) % 返回矩阵 A 的对角线元素
+diag(x) % 构造一个对角阵，对角线元素就是向量 x 的各元素
+eye(m, n) % m x n 阶单位矩阵
+linspace(x1, x2, n) % 返回介于 x1 和 x2 之间的 n 个等距节点
+inv(A) % 矩阵 A 的逆矩阵
+det(A) % 矩阵 A 的行列式
+eig(A) % 矩阵 A 的特征值和特征向量
+trace(A) % 矩阵 A 的迹（即对角线元素之和），等价于 sum(diag(A))
+isempty(A) % 测试 A 是否为空
+all(A) % 测试 A 中所有元素是否都非 0 或都为真（逻辑值）
+any(A) % 测试 A 中是否有元素非 0 或为真（逻辑值）
+isequal(A, B) % 测试 A 和 B是否相等
+numel(A) % 矩阵 A 的元素个数
+triu(x) % 返回 x 的上三角这部分
+tril(x) % 返回 x 的下三角这部分
+cross(A, B) % 返回 A 和 B 的叉积（矢量积、外积）
+dot(A, B) % 返回 A 和 B 的点积（数量积、内积），要求 A 和 B 必须等长
+transpose(A) % A 的转置，等价于 A'
+fliplr(A) % 将一个矩阵左右翻转
+flipud(A) % 将一个矩阵上下翻转
+
+% 矩阵分解
+[L, U, P] = lu(A) % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置换阵
+[P, D] = eig(A) % 特征值分解：AP = PD，D 是由特征值构成的对角阵，P 的各列就是对应的特征向量
+[U, S, V] = svd(X) % 奇异值分解：XV = US，U 和 V 是酉矩阵，S 是由奇异值构成的半正定实数对角阵
+
+% 常用向量函数
+max % 最大值
+min % 最小值
+length % 元素个数
+sort % 按升序排列
+sum % 各元素之和
+prod % 各元素之积
+mode % 众数
+median % 中位数
+mean % 平均值
+std % 标准差
+perms(x) % x 元素的全排列
+
+```
+
+## 相关资料
+
+* 官方网页：[http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* 官方论坛：[http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/zh-cn/perl-cn.html.markdown b/zh-cn/perl-cn.html.markdown new file mode 100644 index 00000000..5b0d6179 --- /dev/null +++ b/zh-cn/perl-cn.html.markdown @@ -0,0 +1,152 @@ +--- +name: perl +category: language +language: perl +filename: learnperl-cn.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] +translators: + - ["Yadong Wen", "https://github.com/yadongwen"] +lang: zh-cn +--- + +Perl 5是一个功能强大、特性齐全的编程语言，有25年的历史。 + +Perl 5可以在包括便携式设备和大型机的超过100个平台上运行，既适用于快速原型构建，也适用于大型项目开发。 + +```perl +# 单行注释以#号开头 + + +#### Perl的变量类型 + +# 变量以$号开头。 +# 合法变量名以英文字母或者下划线起始， +# 后接任意数目的字母、数字或下划线。 + +### Perl有三种主要的变量类型：标量、数组和哈希。 + +## 标量 +# 标量类型代表单个值： +my $animal = "camel"; +my $answer = 42; + +# 标量类型值可以是字符串、整型或浮点类型，Perl会根据需要自动进行类型转换。 + +## 数组 +# 数组类型代表一列值： +my @animals = ("camel", "llama", "owl"); +my @numbers = (23, 42, 69); +my @mixed = ("camel", 42, 1.23); + + + +## 哈希 +# 哈希类型代表一个键/值对的集合： + +my %fruit_color = ("apple", "red", "banana", "yellow"); + +# 可以使用空格和“=>”操作符更清晰的定义哈希： + +my %fruit_color = ( + apple => "red", + banana => "yellow", + ); +# perldata中有标量、数组和哈希更详细的介绍。 (perldoc perldata). + +# 可以用引用构建更复杂的数据类型，比如嵌套的列表和哈希。 + +#### 逻辑和循环结构 + +# Perl有大多数常见的逻辑和循环控制结构 + +if ( $var ) { + ... +} elsif ( $var eq 'bar' ) { + ... +} else { + ... +} + +unless ( condition ) { + ... + } +# 上面这个比"if (!condition)"更可读。 + +# 有Perl特色的后置逻辑结构 +print "Yow!" if $zippy; +print "We have no bananas" unless $bananas; + +# while + while ( condition ) { + ... + } + + +# for和foreach +for ($i = 0; $i <= $max; $i++) { + ... + } + +foreach (@array) { + print "This element is $_\n"; + } + + +#### 正则表达式 + +# Perl对正则表达式有深入广泛的支持，perlrequick和perlretut等文档有详细介绍。简单来说： + +# 简单匹配 +if (/foo/) { ... } # 如果 $_ 包含"foo"逻辑为真 +if ($a =~ /foo/) { ... } # 如果 $a 包含"foo"逻辑为真 + +# 简单替换 + +$a =~ s/foo/bar/; # 将$a中的foo替换为bar +$a =~ s/foo/bar/g; # 将$a中所有的foo替换为bar + + +#### 文件和输入输出 + +# 可以使用“open()”函数打开文件用于输入输出。 + +open(my $in, "<", "input.txt") or die "Can't open input.txt: $!"; +open(my $out, ">", "output.txt") or die "Can't open output.txt: $!"; +open(my $log, ">>", "my.log") or die "Can't open my.log: $!"; + +# 可以用"<>"操作符读取一个打开的文件句柄。 在标量语境下会读取一行， +# 在列表环境下会将整个文件读入并将每一行赋给列表的一个元素： + +my $line = <$in>; +my @lines = <$in>; + +#### 子程序 + +# 写子程序很简单： + +sub logger { + my $logmessage = shift; + open my $logfile, ">>", "my.log" or die "Could not open my.log: $!"; + print $logfile $logmessage; +} + +# 现在可以像内置函数一样调用子程序： + +logger("We have a logger subroutine!"); + + +``` + +#### 使用Perl模块 + +Perl模块提供一系列特性来帮助你避免重新发明轮子，CPAN是下载模块的好地方( http://www.cpan.org/ )。Perl发行版本身也包含很多流行的模块。 + +perlfaq有很多常见问题和相应回答，也经常有对优秀CPAN模块的推荐介绍。 + +#### 深入阅读 + + - [perl-tutorial](http://perl-tutorial.org/) + - [www.perl.com的learn站点](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - 以及 perl 内置的： `perldoc perlintro` diff --git a/zh-cn/php-cn.html.markdown b/zh-cn/php-cn.html.markdown index e3dfe419..2def7f1c 100755..100644 --- a/zh-cn/php-cn.html.markdown +++ b/zh-cn/php-cn.html.markdown @@ -1,11 +1,12 @@ --- -language: php +language: PHP contributors: - ["Malcolm Fell", "http://emarref.net/"] - ["Trismegiste", "https://github.com/Trismegiste"] translators: - - ["Chenbo Li", "http://binarythink.net"] -filename: learnphp.php + - ["Chenbo Li", "http://binarythink.net"] +filename: learnphp-zh.php +lang: zh-cn --- 这份教程所使用的版本是 PHP 5+. @@ -179,7 +180,7 @@ assert($c >= $d); // 下面的比较只有在类型相同、值相同的情况下才为真 assert($c === $d); assert($a !== $d); -assert(1 == '1'); +assert(1 === '1'); assert(1 !== '1'); // 变量可以根据其使用来进行类型转换 @@ -242,7 +243,7 @@ if ($x === '0') { -// 下面的语法常用语模板中: +// 下面的语法常用于模板中: ?> <?php if ($x): ?> @@ -332,7 +333,7 @@ function my_function () { echo my_function(); // => "Hello" // 函数名需要以字母或者下划线开头, -// 后面可以跟着任意的字幕、下划线、数字. +// 后面可以跟着任意的字母、下划线、数字. function add ($x, $y = 1) { // $y 是可选参数，默认值为 1 $result = $x + $y; diff --git a/zh-cn/python-cn.html.markdown b/zh-cn/python-cn.html.markdown new file mode 100644 index 00000000..deb94cdc --- /dev/null +++ b/zh-cn/python-cn.html.markdown @@ -0,0 +1,476 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Chenbo Li", "http://binarythink.net"] +filename: learnpython-zh.py +lang: zh-cn +--- + +Python 由 Guido Van Rossum 在90年代初创建。 它现在是最流行的语言之一 +我喜爱python是因为它有极为清晰的语法，甚至可以说，它就是可以执行的伪代码 + +很欢迎来自您的反馈，你可以在[@louiedinh](http://twitter.com/louiedinh) 和 louiedinh [at] [google's email service] 这里找到我 + +注意: 这篇文章针对的版本是Python 2.7，但大多也可使用于其他Python 2的版本 +如果是Python 3，请在网络上寻找其他教程 + +```python + +# 单行注释 +""" 多行字符串可以用 + 三个引号包裹，不过这也可以被当做 + 多行注释 +""" + +#################################################### +## 1. 原始数据类型和操作符 +#################################################### + +# 数字类型 +3 # => 3 + +# 简单的算数 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7 + +# 整数的除法会自动取整 +5 / 2 # => 2 + +# 要做精确的除法，我们需要引入浮点数 +2.0 # 浮点数 +11.0 / 4.0 # => 2.75 精确多了 + +# 括号具有最高优先级 +(1 + 3) * 2 # => 8 + +# 布尔值也是基本的数据类型 +True +False + +# 用 not 来取非 +not True # => False +not False # => True + +# 相等 +1 == 1 # => True +2 == 1 # => False + +# 不等 +1 != 1 # => False +2 != 1 # => True + +# 更多的比较操作符 +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# 比较运算可以连起来写！ +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# 字符串通过 " 或 ' 括起来 +"This is a string." +'This is also a string.' + +# 字符串通过加号拼接 +"Hello " + "world!" # => "Hello world!" + +# 字符串可以被视为字符的列表 +"This is a string"[0] # => 'T' + +# % 可以用来格式化字符串 +"%s can be %s" % ("strings", "interpolated") + +# 也可以用 format 方法来格式化字符串 +# 推荐使用这个方法 +"{0} can be {1}".format("strings", "formatted") +# 也可以用变量名代替数字 +"{name} wants to eat {food}".format(name="Bob", food="lasagna") + +# None 是对象 +None # => None + +# 不要用相等 `==` 符号来和None进行比较 +# 要用 `is` +"etc" is None # => False +None is None # => True + +# 'is' 可以用来比较对象的相等性 +# 这个操作符在比较原始数据时没多少用，但是比较对象时必不可少 + +# None, 0, 和空字符串都被算作 False +# 其他的均为 True +0 == False # => True +"" == False # => True + + +#################################################### +## 2. 变量和集合 +#################################################### + +# 很方便的输出 +print "I'm Python. Nice to meet you!" + + +# 给变量赋值前不需要事先声明 +some_var = 5 # 一般建议使用小写字母和下划线组合来做为变量名 +some_var # => 5 + +# 访问未赋值的变量会抛出异常 +# 可以查看控制流程一节来了解如何异常处理 +some_other_var # 抛出 NameError + +# if 语句可以作为表达式来使用 +"yahoo!" if 3 > 2 else 2 # => "yahoo!" + +# 列表用来保存序列 +li = [] +# 可以直接初始化列表 +other_li = [4, 5, 6] + +# 在列表末尾添加元素 +li.append(1) # li 现在是 [1] +li.append(2) # li 现在是 [1, 2] +li.append(4) # li 现在是 [1, 2, 4] +li.append(3) # li 现在是 [1, 2, 4, 3] +# 移除列表末尾元素 +li.pop() # => 3 li 现在是 [1, 2, 4] +# 重新加进去 +li.append(3) # li is now [1, 2, 4, 3] again. + +# 像其他语言访问数组一样访问列表 +li[0] # => 1 +# 访问最后一个元素 +li[-1] # => 3 + +# 越界会抛出异常 +li[4] # 抛出越界异常 + +# 切片语法需要用到列表的索引访问 +# 可以看做数学之中左闭右开区间 +li[1:3] # => [2, 4] +# 省略开头的元素 +li[2:] # => [4, 3] +# 省略末尾的元素 +li[:3] # => [1, 2, 4] + +# 删除特定元素 +del li[2] # li 现在是 [1, 2, 3] + +# 合并列表 +li + other_li # => [1, 2, 3, 4, 5, 6] - 并不会不改变这两个列表 + +# 通过拼接来合并列表 +li.extend(other_li) # li 是 [1, 2, 3, 4, 5, 6] + +# 用 in 来返回元素是否在列表中 +1 in li # => True + +# 返回列表长度 +len(li) # => 6 + + +# 元组类似于列表，但它是不可改变的 +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # 类型错误 + +# 对于大多数的列表操作，也适用于元组 +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# 你可以将元组解包赋给多个变量 +a, b, c = (1, 2, 3) # a 是 1，b 是 2，c 是 3 +# 如果不加括号，将会被自动视为元组 +d, e, f = 4, 5, 6 +# 现在我们可以看看交换两个数字是多么容易的事 +e, d = d, e # d 是 5，e 是 4 + + +# 字典用来储存映射关系 +empty_dict = {} +# 字典初始化 +filled_dict = {"one": 1, "two": 2, "three": 3} + +# 字典也用中括号访问元素 +filled_dict["one"] # => 1 + +# 把所有的键保存在列表中 +filled_dict.keys() # => ["three", "two", "one"] +# 键的顺序并不是唯一的，得到的不一定是这个顺序 + +# 把所有的值保存在列表中 +filled_dict.values() # => [3, 2, 1] +# 和键的顺序相同 + +# 判断一个键是否存在 +"one" in filled_dict # => True +1 in filled_dict # => False + +# 查询一个不存在的键会抛出 KeyError +filled_dict["four"] # KeyError + +# 用 get 方法来避免 KeyError +filled_dict.get("one") # => 1 +filled_dict.get("four") # => None +# get 方法支持在不存在的时候返回一个默认值 +filled_dict.get("one", 4) # => 1 +filled_dict.get("four", 4) # => 4 + +# setdefault 是一个更安全的添加字典元素的方法 +filled_dict.setdefault("five", 5) # filled_dict["five"] 的值为 5 +filled_dict.setdefault("five", 6) # filled_dict["five"] 的值仍然是 5 + + +# 集合储存无顺序的元素 +empty_set = set() +# 初始化一个集合 +some_set = set([1, 2, 2, 3, 4]) # some_set 现在是 set([1, 2, 3, 4]) + +# Python 2.7 之后，大括号可以用来表示集合 +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# 向集合添加元素 +filled_set.add(5) # filled_set 现在是 {1, 2, 3, 4, 5} + +# 用 & 来计算集合的交 +other_set = {3, 4, 5, 6} +filled_set & other_set # => {3, 4, 5} + +# 用 | 来计算集合的并 +filled_set | other_set # => {1, 2, 3, 4, 5, 6} + +# 用 - 来计算集合的差 +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# 用 in 来判断元素是否存在于集合中 +2 in filled_set # => True +10 in filled_set # => False + + +#################################################### +## 3. 控制流程 +#################################################### + +# 新建一个变量 +some_var = 5 + +# 这是个 if 语句，在 python 中缩进是很重要的。 +# 下面的代码片段将会输出 "some var is smaller than 10" +if some_var > 10: + print "some_var is totally bigger than 10." +elif some_var < 10: # 这个 elif 语句是不必须的 + print "some_var is smaller than 10." +else: # 这个 else 也不是必须的 + print "some_var is indeed 10." + + +""" +用for循环遍历列表 +输出: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + # 你可以用 % 来格式化字符串 + print "%s is a mammal" % animal + +""" +`range(number)` 返回从0到给定数字的列表 +输出: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +while 循环 +输出: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # x = x + 1 的简写 + +# 用 try/except 块来处理异常 + +# Python 2.6 及以上适用: +try: + # 用 raise 来抛出异常 + raise IndexError("This is an index error") +except IndexError as e: + pass # pass 就是什么都不做，不过通常这里会做一些恢复工作 + + +#################################################### +## 4. 函数 +#################################################### + +# 用 def 来新建函数 +def add(x, y): + print "x is %s and y is %s" % (x, y) + return x + y # 通过 return 来返回值 + +# 调用带参数的函数 +add(5, 6) # => 输出 "x is 5 and y is 6" 返回 11 + +# 通过关键字赋值来调用函数 +add(y=6, x=5) # 顺序是无所谓的 + +# 我们也可以定义接受多个变量的函数，这些变量是按照顺序排列的 +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1,2,3) + + +# 我们也可以定义接受多个变量的函数，这些变量是按照关键字排列的 +def keyword_args(**kwargs): + return kwargs + +# 实际效果： +keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} + +# 你也可以同时将一个函数定义成两种形式 +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) prints: + (1, 2) + {"a": 3, "b": 4} +""" + +# 当调用函数的时候，我们也可以进行相反的操作，把元组和字典展开为参数 +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # 等价于 foo(1, 2, 3, 4) +all_the_args(**kwargs) # 等价于 foo(a=3, b=4) +all_the_args(*args, **kwargs) # 等价于 foo(1, 2, 3, 4, a=3, b=4) + +# 函数在 python 中是一等公民 +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) # => 13 + +# 匿名函数 +(lambda x: x > 2)(3) # => True + +# 内置高阶函数 +map(add_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# 可以用列表方法来对高阶函数进行更巧妙的引用 +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +#################################################### +## 5. 类 +#################################################### + +# 我们新建的类是从 object 类中继承的 +class Human(object): + + # 类属性，由所有类的对象共享 + species = "H. sapiens" + + # 基本构造函数 + def __init__(self, name): + # 将参数赋给对象成员属性 + self.name = name + + # 成员方法，参数要有 self + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # 类方法由所有类的对象共享 + # 这类方法在调用时，会把类本身传给第一个参数 + @classmethod + def get_species(cls): + return cls.species + + # 静态方法是不需要类和对象的引用就可以调用的方法 + @staticmethod + def grunt(): + return "*grunt*" + + +# 实例化一个类 +i = Human(name="Ian") +print i.say("hi") # 输出 "Ian: hi" + +j = Human("Joel") +print j.say("hello") # 输出 "Joel: hello" + +# 访问类的方法 +i.get_species() # => "H. sapiens" + +# 改变共享属性 +Human.species = "H. neanderthalensis" +i.get_species() # => "H. neanderthalensis" +j.get_species() # => "H. neanderthalensis" + +# 访问静态变量 +Human.grunt() # => "*grunt*" + + +#################################################### +## 6. 模块 +#################################################### + +# 我们可以导入其他模块 +import math +print math.sqrt(16) # => 4 + +# 我们也可以从一个模块中导入特定的函数 +from math import ceil, floor +print ceil(3.7) # => 4.0 +print floor(3.7) # => 3.0 + +# 从模块中导入所有的函数 +# 警告：不推荐使用 +from math import * + +# 简写模块名 +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Python的模块其实只是普通的python文件 +# 你也可以创建自己的模块，并且导入它们 +# 模块的名字就和文件的名字相同 + +# 也可以通过下面的方法查看模块中有什么属性和方法 +import math +dir(math) + + +``` + +## 更多阅读 + +希望学到更多？试试下面的链接： + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) diff --git a/zh-cn/python3-cn.html.markdown b/zh-cn/python3-cn.html.markdown new file mode 100644 index 00000000..c223297c --- /dev/null +++ b/zh-cn/python3-cn.html.markdown @@ -0,0 +1,629 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] + - ["Steven Basart", "http://github.com/xksteven"] + - ["Andre Polykanine", "https://github.com/Oire"] +translators: + - ["Geoff Liu", "http://geoffliu.me"] +filename: learnpython3-cn.py +lang: zh-cn +--- + +Python是由吉多·范罗苏姆(Guido Van Rossum)在90年代早期设计。它是如今最常用的编程 +语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。 + +欢迎大家斧正。英文版原作Louie Dinh [@louiedinh](http://twitter.com/louiedinh) +或着Email louiedinh [at] [谷歌的信箱服务]。中文翻译Geoff Liu。 + +注意：这篇教程是特别为Python3写的。如果你想学旧版Python2，我们特别有另一篇教程。 + +```python + +# 用井字符开头的是单行注释 + +""" 多行字符串用三个引号 + 包裹，也常被用来做多 + 行注释 +""" + +#################################################### +## 1. 原始数据类型和运算符 +#################################################### + +# 整数 +3 # => 3 + +# 算术没有什么出乎意料的 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 + +# 但是除法例外，会自动转换成浮点数 +35 / 5 # => 7.0 +5 / 3 # => 1.6666666666666667 + +# 整数除法的结果都是向下取整 +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # 浮点数也可以 +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# 浮点数的运算结果也是浮点数 +3 * 2.0 # => 6.0 + +# 模除 +7 % 3 # => 1 + +# x的y次方 +2**4 # => 16 + +# 用括号决定优先级 +(1 + 3) * 2 # => 8 + +# 布尔值 +True +False + +# 用not取非 +not True # => False +not False # => True + +# 逻辑运算符，注意and和or都是小写 +True and False #=> False +False or True #=> True + +# 整数也可以当作布尔值 +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# 用==判断相等 +1 == 1 # => True +2 == 1 # => False + +# 用!=判断不等 +1 != 1 # => False +2 != 1 # => True + +# 比较大小 +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# 大小比较可以连起来！ +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# 字符串用单引双引都可以 +"这是个字符串" +'这也是个字符串' + +# 用加号连接字符串 +"Hello " + "world!" # => "Hello world!" + +# 字符串可以被当作字符列表 +"This is a string"[0] # => 'T' + +# 用.format来格式化字符串 +"{} can be {}".format("strings", "interpolated") + +# 可以重复参数以节省时间 +"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick") +#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick" + +# 如果不想数参数，可以用关键字 +"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna" + +# 如果你的Python3程序也要在Python2.5以下环境运行，也可以用老式的格式化语法 +"%s can be %s the %s way" % ("strings", "interpolated", "old") + +# None是一个对象 +None # => None + +# 当与None进行比较时不要用 ==，要用is。is是用来比较两个变量是否指向同一个对象。 +"etc" is None # => False +None is None # => True + +# None，0，空字符串，空列表，空字典都算是False +# 所有其他值都是True +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. 变量和集合 +#################################################### + +# print是内置的打印函数 +print("I'm Python. Nice to meet you!") + +# 在给变量赋值前不用提前声明 +# 传统的变量命名是小写，用下划线分隔单词 +some_var = 5 +some_var # => 5 + +# 访问未赋值的变量会抛出异常 +# 参考流程控制一段来学习异常处理 +some_unknown_var # 抛出NameError + +# 用列表(list)储存序列 +li = [] +# 创建列表时也可以同时赋给元素 +other_li = [4, 5, 6] + +# 用append在列表最后追加元素 +li.append(1) # li现在是[1] +li.append(2) # li现在是[1, 2] +li.append(4) # li现在是[1, 2, 4] +li.append(3) # li现在是[1, 2, 4, 3] +# 用pop从列表尾部删除 +li.pop() # => 3 且li现在是[1, 2, 4] +# 把3再放回去 +li.append(3) # li变回[1, 2, 4, 3] + +# 列表存取跟数组一样 +li[0] # => 1 +# 取出最后一个元素 +li[-1] # => 3 + +# 越界存取会造成IndexError +li[4] # 抛出IndexError + +# 列表有切割语法 +li[1:3] # => [2, 4] +# 取尾 +li[2:] # => [4, 3] +# 取头 +li[:3] # => [1, 2, 4] +# 隔一个取一个 +li[::2] # =>[1, 4] +# 倒排列表 +li[::-1] # => [3, 4, 2, 1] +# 可以用三个参数的任何组合来构建切割 +# li[始:终:步伐] + +# 用del删除任何一个元素 +del li[2] # li is now [1, 2, 3] + +# 列表可以相加 +# 注意：li和other_li的值都不变 +li + other_li # => [1, 2, 3, 4, 5, 6] + +# 用extend拼接列表 +li.extend(other_li) # li现在是[1, 2, 3, 4, 5, 6] + +# 用in测试列表是否包含值 +1 in li # => True + +# 用len取列表长度 +len(li) # => 6 + + +# 元组是不可改变的序列 +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # 抛出TypeError + +# 列表允许的操作元组大都可以 +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# 可以把元组合列表解包，赋值给变量 +a, b, c = (1, 2, 3) # 现在a是1，b是2，c是3 +# 元组周围的括号是可以省略的 +d, e, f = 4, 5, 6 +# 交换两个变量的值就这么简单 +e, d = d, e # 现在d是5，e是4 + + +# 用字典表达映射关系 +empty_dict = {} +# 初始化的字典 +filled_dict = {"one": 1, "two": 2, "three": 3} + +# 用[]取值 +filled_dict["one"] # => 1 + + +# 用keys获得所有的键。因为keys返回一个可迭代对象，所以在这里把结果包在list里。我们下面会详细介绍可迭代。 +# 注意：字典键的顺序是不定的，你得到的结果可能和以下不同。 +list(filled_dict.keys()) # => ["three", "two", "one"] + + +# 用values获得所有的值。跟keys一样，要用list包起来，顺序也可能不同。 +list(filled_dict.values()) # => [3, 2, 1] + + +# 用in测试一个字典是否包含一个键 +"one" in filled_dict # => True +1 in filled_dict # => False + +# 访问不存在的键会导致KeyError +filled_dict["four"] # KeyError + +# 用get来避免KeyError +filled_dict.get("one") # => 1 +filled_dict.get("four") # => None +# 当键不存在的时候get方法可以返回默认值 +filled_dict.get("one", 4) # => 1 +filled_dict.get("four", 4) # => 4 + +# setdefault方法只有当键不存在的时候插入新值 +filled_dict.setdefault("five", 5) # filled_dict["five"]设为5 +filled_dict.setdefault("five", 6) # filled_dict["five"]还是5 + +# 字典赋值 +filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} +filled_dict["four"] = 4 # 另一种赋值方法 + +# 用del删除 +del filled_dict["one"] # 从filled_dict中把one删除 + + +# 用set表达集合 +empty_set = set() +# 初始化一个集合，语法跟字典相似。 +some_set = {1, 1, 2, 2, 3, 4} # some_set现在是{1, 2, 3, 4} + +# 可以把集合赋值于变量 +filled_set = some_set + +# 为集合添加元素 +filled_set.add(5) # filled_set现在是{1, 2, 3, 4, 5} + +# & 取交集 +other_set = {3, 4, 5, 6} +filled_set & other_set # => {3, 4, 5} + +# | 取并集 +filled_set | other_set # => {1, 2, 3, 4, 5, 6} + +# - 取补集 +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# in 测试集合是否包含元素 +2 in filled_set # => True +10 in filled_set # => False + + +#################################################### +## 3. 流程控制和迭代器 +#################################################### + +# 先随便定义一个变量 +some_var = 5 + +# 这是个if语句。注意缩进在Python里是有意义的 +# 印出"some_var比10小" +if some_var > 10: + print("some_var比10大") +elif some_var < 10: # elif句是可选的 + print("some_var比10小") +else: # else也是可选的 + print("some_var就是10") + + +""" +用for循环语句遍历列表 +打印: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + print("{} is a mammal".format(animal)) + +""" +"range(number)"返回数字列表从0到给的数字 +打印: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +while循环直到条件不满足 +打印: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # x = x + 1 的简写 + +# 用try/except块处理异常状况 +try: + # 用raise抛出异常 + raise IndexError("This is an index error") +except IndexError as e: + pass # pass是无操作，但是应该在这里处理错误 +except (TypeError, NameError): + pass # 可以同时处理不同类的错误 +else: # else语句是可选的，必须在所有的except之后 + print("All good!") # 只有当try运行完没有错误的时候这句才会运行 + + +# Python提供一个叫做可迭代(iterable)的基本抽象。一个可迭代对象是可以被当作序列 +# 的对象。比如说上面range返回的对象就是可迭代的。 + +filled_dict = {"one": 1, "two": 2, "three": 3} +our_iterable = filled_dict.keys() +print(our_iterable) # => range(1,10) 是一个实现可迭代接口的对象 + +# 可迭代对象可以遍历 +for i in our_iterable: + print(i) # 打印 one, two, three + +# 但是不可以随机访问 +our_iterable[1] # 抛出TypeError + +# 可迭代对象知道怎么生成迭代器 +our_iterator = iter(our_iterable) + +# 迭代器是一个可以记住遍历的位置的对象 +# 用__next__可以取得下一个元素 +our_iterator.__next__() #=> "one" + +# 再一次调取__next__时会记得位置 +our_iterator.__next__() #=> "two" +our_iterator.__next__() #=> "three" + +# 当迭代器所有元素都取出后，会抛出StopIteration +our_iterator.__next__() # 抛出StopIteration + +# 可以用list一次取出迭代器所有的元素 +list(filled_dict.keys()) #=> Returns ["one", "two", "three"] + + + +#################################################### +## 4. 函数 +#################################################### + +# 用def定义新函数 +def add(x, y): + print("x is {} and y is {}".format(x, y)) + return x + y # 用return语句返回 + +# 调用函数 +add(5, 6) # => 印出"x is 5 and y is 6"并且返回11 + +# 也可以用关键字参数来调用函数 +add(y=6, x=5) # 关键字参数可以用任何顺序 + + +# 我们可以定义一个可变参数函数 +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1, 2, 3) + + +# 我们也可以定义一个关键字可变参数函数 +def keyword_args(**kwargs): + return kwargs + +# 我们来看看结果是什么： +keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} + + +# 这两种可变参数可以混着用 +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) prints: + (1, 2) + {"a": 3, "b": 4} +""" + +# 调用可变参数函数时可以做跟上面相反的，用*展开序列，用**展开字典。 +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # 相当于 foo(1, 2, 3, 4) +all_the_args(**kwargs) # 相当于 foo(a=3, b=4) +all_the_args(*args, **kwargs) # 相当于 foo(1, 2, 3, 4, a=3, b=4) + + +# 函数作用域 +x = 5 + +def setX(num): + # 局部作用域的x和全局域的x是不同的 + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # 现在全局域的x被赋值 + print (x) # => 6 + +setX(43) +setGlobalX(6) + + +# 函数在Python是一等公民 +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) # => 13 + +# 也有匿名函数 +(lambda x: x > 2)(3) # => True + +# 内置的高阶函数 +map(add_10, [1, 2, 3]) # => [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# 用列表推导式可以简化映射和过滤。列表推导式的返回值是另一个列表。 +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +#################################################### +## 5. 类 +#################################################### + + +# 定义一个继承object的类 +class Human(object): + + # 类属性，被所有此类的实例共用。 + species = "H. sapiens" + + # 构造方法，当实例被初始化时被调用。注意名字前后的双下划线，这是表明这个属 + # 性或方法对Python有特殊意义，但是允许用户自行定义。你自己取名时不应该用这 + # 种格式。 + def __init__(self, name): + # Assign the argument to the instance's name attribute + self.name = name + + # 实例方法，第一个参数总是self，就是这个实例对象 + def say(self, msg): + return "{name}: {message}".format(name=self.name, message=msg) + + # 类方法，被所有此类的实例共用。第一个参数是这个类对象。 + @classmethod + def get_species(cls): + return cls.species + + # 静态方法。调用时没有实例或类的绑定。 + @staticmethod + def grunt(): + return "*grunt*" + + +# 构造一个实例 +i = Human(name="Ian") +print(i.say("hi")) # 印出 "Ian: hi" + +j = Human("Joel") +print(j.say("hello")) # 印出 "Joel: hello" + +# 调用一个类方法 +i.get_species() # => "H. sapiens" + +# 改一个共用的类属性 +Human.species = "H. neanderthalensis" +i.get_species() # => "H. neanderthalensis" +j.get_species() # => "H. neanderthalensis" + +# 调用静态方法 +Human.grunt() # => "*grunt*" + + +#################################################### +## 6. 模块 +#################################################### + +# 用import导入模块 +import math +print(math.sqrt(16)) # => 4 + +# 也可以从模块中导入个别值 +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# 可以导入一个模块中所有值 +# 警告：不建议这么做 +from math import * + +# 如此缩写模块名字 +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Python模块其实就是普通的Python文件。你可以自己写，然后导入， +# 模块的名字就是文件的名字。 + +# 你可以这样列出一个模块里所有的值 +import math +dir(math) + + +#################################################### +## 7. 高级用法 +#################################################### + +# 用生成器(generators)方便地写惰性运算 +def double_numbers(iterable): + for i in iterable: + yield i + i + +# 生成器只有在需要时才计算下一个值。它们每一次循环只生成一个值，而不是把所有的 +# 值全部算好。这意味着double_numbers不会生成大于15的数字。 +# +# range的返回值也是一个生成器，不然一个1到900000000的列表会花很多时间和内存。 +# +# 如果你想用一个Python的关键字当作变量名，可以加一个下划线来区分。 +range_ = range(1, 900000000) +# 当找到一个 >=30 的结果就会停 +for i in double_numbers(range_): + print(i) + if i >= 30: + break + + +# 装饰器(decorators) +# 这个例子中，beg装饰say +# beg会先调用say。如果返回的say_please为真，beg会改变返回的字符串。 +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please + + +print(say()) # Can you buy me a beer? +print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( +``` + +## 想继续学吗？ + +### 线上免费材料（英文） + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) + +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/3/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) + +### 书籍（也是英文） + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + diff --git a/zh-cn/r-cn.html.markdown b/zh-cn/r-cn.html.markdown new file mode 100644 index 00000000..0c46bc22 --- /dev/null +++ b/zh-cn/r-cn.html.markdown @@ -0,0 +1,541 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["小柒", "http://weibo.com/u/2328126220"] + - ["alswl", "https://github.com/alswl"] +filename: learnr-zh.r +lang: zh-cn +--- + +R 是一门统计语言。它有很多数据分析和挖掘程序包。可以用来统计、分析和制图。 +你也可以在 LaTeX 文档中运行 `R` 命令。 + +```r +# 评论以 # 开始 + +# R 语言原生不支持 多行注释 +# 但是你可以像这样来多行注释 + +# 在窗口里按回车键可以执行一条命令 + + +################################################################### +# 不用懂编程就可以开始动手了 +################################################################### + +data() # 浏览内建的数据集 +data(rivers) # 北美主要河流的长度（数据集） +ls() # 在工作空间中查看「河流」是否出现 +head(rivers) # 撇一眼数据集 +# 735 320 325 392 524 450 +length(rivers) # 我们测量了多少条河流？ +# 141 +summary(rivers) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 +stem(rivers) # 茎叶图（一种类似于直方图的展现形式） +# +# The decimal point is 2 digit(s) to the right of the | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + + +stem(log(rivers)) # 查看数据集的方式既不是标准形式，也不是取log后的结果! 看起来，是钟形曲线形式的基本数据集 + +# The decimal point is 1 digit(s) to the left of the | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + + +hist(rivers, col="#333333", border="white", breaks=25) # 试试用这些参数画画 （译者注：给 river 做统计频数直方图，包含了这些参数：数据源，颜色，边框，空格） +hist(log(rivers), col="#333333", border="white", breaks=25) #你还可以做更多式样的绘图 + +# 还有其他一些简单的数据集可以被用来加载。R 语言包括了大量这种 data() +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", main="Number of important discoveries per year") +# 译者注：参数为（数据源，颜色，线条宽度，X 轴名称，标题） +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", main="Number of important discoveries per year") + + +# 除了按照默认的年份排序，我们还可以排序来发现特征 +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) # 译者注：茎叶图（数据，放大系数） +# +# The decimal point is at the | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 + +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + + + + +#基本的统计学操作也不需要任何编程知识 + +#随机生成数据 +round(runif(7, min=.5, max=6.5)) +# 译者注：runif 产生随机数，round 四舍五入 +# 1 4 6 1 4 6 4 + +# 你输出的结果会和我们给出的不同，除非我们设置了相同的随机种子 random.seed(31337) + + +#从标准高斯函数中随机生成 9 次 +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + + + + + + + +######################### +# 基础编程 +######################### + +# 数值 + +#“数值”指的是双精度的浮点数 +5 # 5 +class(5) # "numeric" +5e4 # 50000 # 用科学技术法方便的处理极大值、极小值或者可变的量级 +6.02e23 # 阿伏伽德罗常数# +1.6e-35 # 布朗克长度 + +# 长整数并用 L 结尾 +5L # 5 +#输出5L +class(5L) # "integer" + +# 可以自己试一试？用 class() 函数获取更多信息 +# 事实上，你可以找一些文件查阅 `xyz` 以及xyz的差别 +# `xyz` 用来查看源码实现，?xyz 用来看帮助 + +# 算法 +10 + 66 # 76 +53.2 - 4 # 49.2 +2 * 2.0 # 4 +3L / 4 # 0.75 +3 %% 2 # 1 + +# 特殊数值类型 +class(NaN) # "numeric" +class(Inf) # "numeric" +class(-Inf) # "numeric" # 在以下场景中会用到 integrate( dnorm(x), 3, Inf ) -- 消除 Z 轴数据 + +# 但要注意，NaN 并不是唯一的特殊数值类型…… +class(NA) # 看上面 +class(NULL) # NULL + + +# 简单列表 +c(6, 8, 7, 5, 3, 0, 9) # 6 8 7 5 3 0 9 +c('alef', 'bet', 'gimmel', 'dalet', 'he') +c('Z', 'o', 'r', 'o') == "Zoro" # FALSE FALSE FALSE FALSE + +# 一些优雅的内置功能 +5:15 # 5 6 7 8 9 10 11 12 13 14 15 + +seq(from=0, to=31337, by=1337) +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +letters +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" + +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + + +# Access the n'th element of a list with list.name[n] or sometimes list.name[[n]] +# 使用 list.name[n] 来访问第 n 个列表元素，有时候需要使用 list.name[[n]] +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 + + + +# 字符串 + +# 字符串和字符在 R 语言中没有区别 +"Horatio" # "Horatio" +class("Horatio") # "character" +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." + + + +# 逻辑值 + +# 布尔值 +class(TRUE) # "logical" +class(FALSE) # "logical" +# 和我们预想的一样 +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# 缺失数据（NA）也是逻辑值 +class(NA) # "logical" +#定义NA为逻辑型 + + + +# 因子 +# 因子是为数据分类排序设计的（像是排序小朋友们的年级或性别） +levels(factor(c("female", "male", "male", "female", "NA", "female"))) # "female" "male" "NA" + +factor(c("female", "female", "male", "NA", "female")) +# female female male NA female +# Levels: female male NA + +data(infert) # 自然以及引产导致的不育症 +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + + + +# 变量 + +# 有许多种方式用来赋值 +x = 5 # 这样可以 +y <- "1" # 更推荐这样 +TRUE -> z # 这样可行，但是很怪 + +#我们还可以使用强制转型 +as.numeric(y) # 1 +as.character(x) # "5" + +# 循环 + +# for 循环语句 +for (i in 1:4) { + print(i) +} + +# while 循环 +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} + +# 记住，在 R 语言中 for / while 循环都很慢 +# 建议使用 apply()（我们一会介绍）来错做一串数据（比如一列或者一行数据） + +# IF/ELSE + +# 再来看这些优雅的标准 +if (4 > 3) { + print("Huzzah! It worked!") +} else { + print("Noooo! This is blatantly illogical!") +} + +# => +# [1] "Huzzah! It worked!" + +# 函数 + +# 定义如下 +jiggle <- function(x) { + x + rnorm(x, sd=.1) #add in a bit of (controlled) noise + return(x) +} + +# 和其他 R 语言函数一样调用 +jiggle(5) # 5±ε. 使用 set.seed(2716057) 后， jiggle(5)==5.005043 + +######################### +# 数据容器：vectors, matrices, data frames, and arrays +######################### + +# 单维度 +# 你可以将目前我们学习到的任何类型矢量化，只要它们拥有相同的类型 +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# 矢量的类型是这一组数据元素的类型 +class(vec) # "numeric" +# If you vectorize items of different classes, weird coercions happen +#如果你强制的将不同类型数值矢量化，会出现特殊值 +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" + +#我们这样来取内部数据，（R 的下标索引顺序 1 开始） +vec[1] # 8 +# 我们可以根据条件查找特定数据 +which(vec %% 2 == 0) # 1 3 +# 抓取矢量中第一个和最后一个字符 +head(vec, 1) # 8 +tail(vec, 1) # 11 +#如果下标溢出或不存会得到 NA +vec[6] # NA +# 你可以使用 length() 获取矢量的长度 +length(vec) # 4 + +# 你可以直接操作矢量或者矢量的子集 +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +# 这里有许多内置的函数，来表现向量 +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 + +# 二维（相同元素类型） + +#你可以为同样类型的变量建立矩阵 +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# 和 vector 不一样的是，一个矩阵的类型真的是 「matrix」，而不是内部元素的类型 +class(mat) # => "matrix" +# 访问第一行的字符 +mat[1,] # 1 4 +# 操作第一行数据 +3 * mat[,1] # 3 6 9 +# 访问一个特定数据 +mat[3,2] # 6 +# 转置整个矩阵（译者注：变成 2 行 3 列） +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# 使用 cbind() 函数把两个矩阵按列合并，形成新的矩阵 +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" +# [4,] "4" "dog" +class(mat2) # matrix +# Again, note what happened! +# 注意 +# 因为矩阵内部元素必须包含同样的类型 +# 所以现在每一个元素都转化成字符串 +c(class(mat2[,1]), class(mat2[,2])) + +# 按行合并两个向量，建立新的矩阵 +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# 哈哈，数据类型都一样的，没有发生强制转换，生活真美好 + +# 二维(不同的元素类型) + +# 利用 data frame 可以将不同类型数据放在一起 +dat <- data.frame(c(5,2,1,4), c("dog", "cat", "bird", "dog")) +names(dat) <- c("number", "species") # 给数据列命名 +class(dat) # "data.frame" +dat +# => +# number species +# 1 5 dog +# 2 2 cat +# 3 1 bird +# 4 4 dog +class(dat$number) # "numeric" +class(dat[,2]) # "factor" +# data.frame() 会将字符向量转换为 factor 向量 + +# 有很多精妙的方法来获取 data frame 的子数据集 +dat$number # 5 2 1 4 +dat[,1] # 5 2 1 4 +dat[,"number"] # 5 2 1 4 + +# 多维（相同元素类型） + +# 使用 arry 创造一个 n 维的表格 +# You can make a two-dimensional table (sort of like a matrix) +# 你可以建立一个 2 维表格（有点像矩阵） +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +#你也可以利用数组建立一个三维的矩阵 +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +#列表（多维的，不同类型的） + +# R语言有列表的形式 +list1 <- list(time = 1:40) +list1$price = c(rnorm(40,.5*list1$time,4)) # 随机 +list1 + +# You can get items in the list like so +# 你可以这样获得列表的元素 +list1$time +# You can subset list items like vectors +# 你也可以和矢量一样获取他们的子集 +list1$price[4] + +######################### +# apply()函数家族 +######################### + +# 还记得 mat 么？ +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Use apply(X, MARGIN, FUN) to apply function FUN to a matrix X +# 使用(X, MARGIN, FUN)将函数 FUN 应用到矩阵 X 的行 (MAR = 1) 或者 列 (MAR = 2) +# That is, R does FUN to each row (or column) of X, much faster than a +# R 在 X 的每一行/列使用 FUN，比循环要快很多 +apply(mat, MAR = 2, myFunc) +# => +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# 还有其他家族函数 ?lapply, ?sapply + +# 不要被吓到，虽然许多人在此都被搞混 +# plyr 程序包的作用是用来改进 apply() 函数家族 + +install.packages("plyr") +require(plyr) +?plyr + +######################### +# 载入数据 +######################### + +# "pets.csv" 是网上的一个文本 +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +pets +head(pets, 2) # 前两行 +tail(pets, 1) # 最后一行 + +# 以 .csv 格式来保存数据集或者矩阵 +write.csv(pets, "pets2.csv") # 保存到新的文件 pets2.csv +# set working directory with setwd(), look it up with getwd() +# 使用 setwd() 改变工作目录，使用 getwd() 查看当前工作目录 + +# 尝试使用 ?read.csv 和 ?write.csv 来查看更多信息 + +######################### +# 画图 +######################### + +# 散点图 +plot(list1$time, list1$price, main = "fake data") # 译者注：横轴 list1$time，纵轴 wlist1$price，标题 fake data +# 回归图 +linearModel <- lm(price ~ time, data = list1) # 译者注：线性模型，数据集为list1，以价格对时间做相关分析模型 +linearModel # 拟合结果 +# 将拟合结果展示在图上，颜色设为红色 +abline(linearModel, col = "red") +# 也可以获取各种各样漂亮的分析图 +plot(linearModel) + +# 直方图 +hist(rpois(n = 10000, lambda = 5), col = "thistle") # 译者注：统计频数直方图 + +# 柱状图 +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + +# 可以尝试着使用 ggplot2 程序包来美化图片 +install.packages("ggplot2") +require(ggplot2) +?ggplot2 + +``` + +## 获得 R + +* 从 [http://www.r-project.org/](http://www.r-project.org/) 获得安装包和图形化界面 +* [RStudio](http://www.rstudio.com/ide/) 是另一个图形化界面 diff --git a/zh-cn/racket-cn.html.markdown b/zh-cn/racket-cn.html.markdown new file mode 100644 index 00000000..8ef3671f --- /dev/null +++ b/zh-cn/racket-cn.html.markdown @@ -0,0 +1,608 @@ +--- + +language: racket +lang: zh-cn +filename: learnracket-zh.rkt +contributors: + - ["th3rac25", "https://github.com/voila"] + - ["Eli Barzilay", "https://github.com/elibarzilay"] + - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"] +translators: + - ["lyuehh", "https://github.com/lyuehh"] +--- + +Racket是Lisp/Scheme家族中的一个通用的，多范式的编程语言。 +非常期待您的反馈！你可以通过[@th3rac25](http://twitter.com/th3rac25)或以用户名为 th3rac25 的Google邮箱服务和我取得联系 + +```racket +#lang racket ; 声明我们使用的语言 + +;;; 注释 + +;; 单行注释以分号开始 + +#| 块注释 + 可以横跨很多行而且... + #| + 可以嵌套 + |# +|# + +;; S表达式注释忽略剩下的表达式 +;; 在调试的时候会非常有用 +#; (被忽略的表达式) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. 原始数据类型和操作符 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 数字 +9999999999999999999999 ; 整数 +#b111 ; 二进制数字 => 7 +#o111 ; 八进制数字 => 73 +#x111 ; 十六进制数字 => 273 +3.14 ; 实数 +6.02e+23 +1/2 ; 有理数 +1+2i ; 复数 + +;; 函数调用写作(f x y z ...) +;; 在这里 f 是一个函数， x, y, z, ... 是参数 +;; 如果你想创建一个列表数据的字面量, 使用 ' 来阻止它们 +;; 被求值 +'(+ 1 2) ; => (+ 1 2) +;; 接下来，是一些数学运算 +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(quotient 5 2) ; => 2 +(remainder 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(exact->inexact 1/3) ; => 0.3333333333333333 +(+ 1+2i 2-3i) ; => 3-1i + +;;; 布尔类型 +#t ; 为真 +#f ; 为假，#f 之外的任何值都是真 +(not #t) ; => #f +(and 0 #f (error "doesn't get here")) ; => #f +(or #f 0 (error "doesn't get here")) ; => 0 + +;;; 字符 +#\A ; => #\A +#\λ ; => #\λ +#\u03BB ; => #\λ + +;;; 字符串是字符组成的定长数组 +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; \是转义字符 +"Foo\tbar\41\x21\u0021\a\r\n" ; 包含C语言的转义字符，和Unicode +"λx:(μα.α→α).xx" ; 字符串可以包含Unicode字符 + +;; 字符串可以相加 +(string-append "Hello " "world!") ; => "Hello world!" + +;; 一个字符串可以看做是一个包含字符的列表 +(string-ref "Apple" 0) ; => #\A + +;; format 可以用来格式化字符串 +(format "~a can be ~a" "strings" "formatted") + +;; 打印字符串非常简单 +(printf "I'm Racket. Nice to meet you!\n") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. 变量 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 你可以使用 define 定义一个变量 +;; 变量的名字可以使用任何字符除了: ()[]{}",'`;#|\ +(define some-var 5) +some-var ; => 5 + +;; 你也可以使用Unicode字符 +(define ⊆ subset?) +(⊆ (set 3 2) (set 1 2 3)) ; => #t + +;; 访问未赋值的变量会引发一个异常 +; x ; => x: undefined ... + +;; 本地绑定: `me' 被绑定到 "Bob"，并且只在 let 中生效 +(let ([me "Bob"]) + "Alice" + me) ; => "Bob" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 结构和集合 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 结构体 +(struct dog (name breed age)) +(define my-pet + (dog "lassie" "collie" 5)) +my-pet ; => #<dog> +(dog? my-pet) ; => #t +(dog-name my-pet) ; => "lassie" + +;;; 对 (不可变的) +;; `cons' 返回对, `car' 和 `cdr' 从对中提取第1个 +;; 和第2个元素 +(cons 1 2) ; => '(1 . 2) +(car (cons 1 2)) ; => 1 +(cdr (cons 1 2)) ; => 2 + +;;; 列表 + +;; 列表由链表构成, 由 `cons' 的结果 +;; 和一个 `null' (或者 '()) 构成，后者标记了这个列表的结束 +(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3) +;; `list' 给列表提供了一个非常方便的可变参数的生成器 +(list 1 2 3) ; => '(1 2 3) +;; 一个单引号也可以用来表示一个列表字面量 +'(1 2 3) ; => '(1 2 3) + +;; 仍然可以使用 `cons' 在列表的开始处添加一项 +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; `append' 函数可以将两个列表合并 +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; 列表是非常基础的类型，所以有*很多*操作列表的方法 +;; 下面是一些例子: +(map add1 '(1 2 3)) ; => '(2 3 4) +(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(filter even? '(1 2 3 4)) ; => '(2 4) +(count even? '(1 2 3 4)) ; => 2 +(take '(1 2 3 4) 2) ; => '(1 2) +(drop '(1 2 3 4) 2) ; => '(3 4) + +;;; 向量 + +;; 向量是定长的数组 +#(1 2 3) ; => '#(1 2 3) + +;; 使用 `vector-append' 方法将2个向量合并 +(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Set(翻译成集合也不太合适，所以不翻译了..) + +;; 从一个列表创建一个Set +(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3) + +;; 使用 `set-add' 增加一个成员 +;; (函数式特性: 这里会返回一个扩展后的Set，而不是修改输入的值) +(set-add (set 1 2 3) 4) ; => (set 1 2 3 4) + +;; 使用 `set-remove' 移除一个成员 +(set-remove (set 1 2 3) 1) ; => (set 2 3) + +;; 使用 `set-member?' 测试成员是否存在 +(set-member? (set 1 2 3) 1) ; => #t +(set-member? (set 1 2 3) 4) ; => #f + +;;; 散列表 + +;; 创建一个不变的散列表 (可变散列表的例子在下面) +(define m (hash 'a 1 'b 2 'c 3)) + +;; 根据键取得值 +(hash-ref m 'a) ; => 1 + +;; 获取一个不存在的键是一个异常 +; (hash-ref m 'd) => 没有找到元素 + +;; 你可以给不存在的键提供一个默认值 +(hash-ref m 'd 0) ; => 0 + +;; 使用 `hash-set' 来扩展一个不可变的散列表 +;; (返回的是扩展后的散列表而不是修改它) +(define m2 (hash-set m 'd 4)) +m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3)) + +;; 记住，使用 `hash` 创建的散列表是不可变的 +m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' + +;; 使用 `hash-remove' 移除一个键值对 (函数式特性，m并不变) +(hash-remove m 'a) ; => '#hash((b . 2) (c . 3)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. 函数 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 使用 `lambda' 创建函数 +;; 函数总是返回它最后一个表达式的值 +(lambda () "Hello World") ; => #<procedure> +;; 也可以使用 Unicode 字符 `λ' +(λ () "Hello World") ; => 同样的函数 + +;; 使用括号调用一个函数，也可以直接调用一个 lambda 表达式 +((lambda () "Hello World")) ; => "Hello World" +((λ () "Hello World")) ; => "Hello World" + +;; 将函数赋值为一个变量 +(define hello-world (lambda () "Hello World")) +(hello-world) ; => "Hello World" + +;; 你可以使用函数定义的语法糖来简化代码 +(define (hello-world2) "Hello World") + +;; `()`是函数的参数列表 +(define hello + (lambda (name) + (string-append "Hello " name))) +(hello "Steve") ; => "Hello Steve" +;; 同样的，可以使用语法糖来定义: +(define (hello2 name) + (string-append "Hello " name)) + +;; 你也可以使用可变参数， `case-lambda' +(define hello3 + (case-lambda + [() "Hello World"] + [(name) (string-append "Hello " name)])) +(hello3 "Jake") ; => "Hello Jake" +(hello3) ; => "Hello World" +;; ... 或者给参数指定一个可选的默认值 +(define (hello4 [name "World"]) + (string-append "Hello " name)) + +;; 函数可以将多余的参数放到一个列表里 +(define (count-args . args) + (format "You passed ~a args: ~a" (length args) args)) +(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)" +;; ... 也可以使用不带语法糖的 `lambda' 形式: +(define count-args2 + (lambda args + (format "You passed ~a args: ~a" (length args) args))) + +;; 你可以混用两种用法 +(define (hello-count name . args) + (format "Hello ~a, you passed ~a extra args" name (length args))) +(hello-count "Finn" 1 2 3) +; => "Hello Finn, you passed 3 extra args" +;; ... 不带语法糖的形式: +(define hello-count2 + (lambda (name . args) + (format "Hello ~a, you passed ~a extra args" name (length args)))) + +;; 使用关键字 +(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args) + (format "~a ~a, ~a extra args" g name (length args))) +(hello-k) ; => "Hello World, 0 extra args" +(hello-k 1 2 3) ; => "Hello World, 3 extra args" +(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args" +(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args" +(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6) + ; => "Hi Finn, 6 extra args" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. 判断是否相等 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 判断数字使用 `=' +(= 3 3.0) ; => #t +(= 2 1) ; => #f + +;; 判断对象使用 `eq?' +(eq? 3 3) ; => #t +(eq? 3 3.0) ; => #f +(eq? (list 3) (list 3)) ; => #f + +;; 判断集合使用 `equal?' +(equal? (list 'a 'b) (list 'a 'b)) ; => #t +(equal? (list 'a 'b) (list 'b 'a)) ; => #f + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. 控制结构 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; 条件判断 + +(if #t ; 测试表达式 + "this is true" ; 为真的表达式 + "this is false") ; 为假的表达式 +; => "this is true" + +;; 注意, 除 `#f` 之外的所有值都认为是真 +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'yep + +;; `cond' 会进行一系列的判断来选择一个结果 +(cond [(> 2 2) (error "wrong!")] + [(< 2 2) (error "wrong again!")] + [else 'ok]) ; => 'ok + +;;; 模式匹配 + +(define (fizzbuzz? n) + (match (list (remainder n 3) (remainder n 5)) + [(list 0 0) 'fizzbuzz] + [(list 0 _) 'fizz] + [(list _ 0) 'buzz] + [_ #f])) + +(fizzbuzz? 15) ; => 'fizzbuzz +(fizzbuzz? 37) ; => #f + +;;; 循环 + +;; 循环可以使用递归(尾递归) +(define (loop i) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) +(loop 5) ; => i=5, i=6, ... + +;; 类似的，可以使用 `let` 定义 +(let loop ((i 0)) + (when (< i 10) + (printf "i=~a\n" i) + (loop (add1 i)))) ; => i=0, i=1, ... + +;; 看上面的例子怎么增加一个新的 `loop' 形式, 但是 Racket 已经有了一个非常 +;; 灵活的 `for' 了: +(for ([i 10]) + (printf "i=~a\n" i)) ; => i=0, i=1, ... +(for ([i (in-range 5 10)]) + (printf "i=~a\n" i)) ; => i=5, i=6, ... + +;;; 其他形式的迭代 +;; `for' 允许在很多数据结构中迭代: +;; 列表, 向量, 字符串, Set, 散列表, 等... + +(for ([i (in-list '(l i s t))]) + (displayln i)) + +(for ([i (in-vector #(v e c t o r))]) + (displayln i)) + +(for ([i (in-string "string")]) + (displayln i)) + +(for ([i (in-set (set 'x 'y 'z))]) + (displayln i)) + +(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))]) + (printf "key:~a value:~a\n" k v)) + +;;; 更多复杂的迭代 + +;; 并行扫描多个序列 (遇到长度小的就停止) +(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x 1:y 2:z + +;; 嵌套循环 +(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j)) +; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z + +;; 带有条件判断的 `for` +(for ([i 1000] + #:when (> i 5) + #:unless (odd? i) + #:break (> i 10)) + (printf "i=~a\n" i)) +; => i=6, i=8, i=10 + +;;; 更多的例子帮助你加深理解.. +;; 和 `for' 循环非常像 -- 收集结果 + +(for/list ([i '(1 2 3)]) + (add1 i)) ; => '(2 3 4) + +(for/list ([i '(1 2 3)] #:when (even? i)) + i) ; => '(2) + +(for/list ([i 10] [j '(x y z)]) + (list i j)) ; => '((0 x) (1 y) (2 z)) + +(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10)) + i) ; => '(6 8 10) + +(for/hash ([i '(1 2 3)]) + (values i (number->string i))) +; => '#hash((1 . "1") (2 . "2") (3 . "3")) + +;; 也有很多其他的内置方法来收集循环中的值: +(for/sum ([i 10]) (* i i)) ; => 285 +(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 +(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t +(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t +;; 如果需要合并计算结果, 使用 `for/fold' +(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10 +;; (这个函数可以在大部分情况下替代普通的命令式循环) + +;;; 异常 + +;; 要捕获一个异常，使用 `with-handlers' 形式 +(with-handlers ([exn:fail? (lambda (exn) 999)]) + (+ 1 "2")) ; => 999 +(with-handlers ([exn:break? (lambda (exn) "no time")]) + (sleep 3) + "phew") ; => "phew", 如果你打断了它，那么结果 => "no time" + +;; 使用 `raise' 抛出一个异常后者其他任何值 +(with-handlers ([number? ; 捕获抛出的数字类型的值 + identity]) ; 将它们作为普通值 + (+ 1 (raise 2))) ; => 2 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. 可变的值 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 使用 `set!' 给一个已经存在的变量赋一个新值 +(define n 5) +(set! n (add1 n)) +n ; => 6 + +;; 给那些明确地需要变化的值使用 `boxes` (在其他语言里类似指针 +;; 或者引用) +(define n* (box 5)) +(set-box! n* (add1 (unbox n*))) +(unbox n*) ; => 6 + +;; 很多 Racket 诗句类型是不可变的 (对，列表，等)，有一些既是可变的 +;; 又是不可变的 (字符串，向量，散列表 +;; 等...) + +;; 使用 `vector' 或者 `make-vector' 创建一个可变的向量 +(define vec (vector 2 2 3 4)) +(define wall (make-vector 100 'bottle-of-beer)) +;; 使用 `vector-set!` 更新一项 +(vector-set! vec 0 1) +(vector-set! wall 99 'down) +vec ; => #(1 2 3 4) + +;; 创建一个空的可变散列表，然后操作它 +(define m3 (make-hash)) +(hash-set! m3 'a 1) +(hash-set! m3 'b 2) +(hash-set! m3 'c 3) +(hash-ref m3 'a) ; => 1 +(hash-ref m3 'd 0) ; => 0 +(hash-remove! m3 'a) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. 模块 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 模块让你将你的代码组织为多个文件，成为可重用的模块， +;; 在这里，我们使用嵌套在本文的整个大模块 +;; 里的子模块(从 "#lang" 这一行开始) + +(module cake racket/base ; 基于 racket/base 定义一个 `cake` 模块 + + (provide print-cake) ; 这个模块导出的函数 + + (define (print-cake n) + (show " ~a " n #\.) + (show " .-~a-. " n #\|) + (show " | ~a | " n #\space) + (show "---~a---" n #\-)) + + (define (show fmt n ch) ; 内部函数 + (printf fmt (make-string n ch)) + (newline))) + +;; 使用 `require` 从模块中得到所有 `provide` 的函数 +(require 'cake) ; 这里的 `'`表示是本地的子模块 +(print-cake 3) +; (show "~a" 1 #\A) ; => 报错, `show' 没有被导出，不存在 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. 类和对象 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 创建一个 fish% 类(%是给类绑定用的) +(define fish% + (class object% + (init size) ; 初始化的参数 + (super-new) ; 父类的初始化 + ;; 域 + (define current-size size) + ;; 公共方法 + (define/public (get-size) + current-size) + (define/public (grow amt) + (set! current-size (+ amt current-size))) + (define/public (eat other-fish) + (grow (send other-fish get-size))))) + +;; 创建一个 fish% 类的示例 +(define charlie + (new fish% [size 10])) + +;; 使用 `send' 调用一个对象的方法 +(send charlie get-size) ; => 10 +(send charlie grow 6) +(send charlie get-size) ; => 16 + +;; `fish%' 是一个普通的值，我们可以用它来混入 +(define (add-color c%) + (class c% + (init color) + (super-new) + (define my-color color) + (define/public (get-color) my-color))) +(define colored-fish% (add-color fish%)) +(define charlie2 (new colored-fish% [size 10] [color 'red])) +(send charlie2 get-color) +;; 或者，不带名字 +(send (new (add-color fish%) [size 10] [color 'red]) get-color) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 9. 宏 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 宏让你扩展这门语言的语法 + +;; 让我们定义一个while循环 +(define-syntax-rule (while condition body ...) + (let loop () + (when condition + body ... + (loop)))) + +(let ([i 0]) + (while (< i 10) + (displayln i) + (set! i (add1 i)))) + +;; 宏是安全的，你不能修改现有的变量 +(define-syntax-rule (swap! x y) ; !表示会修改 + (let ([tmp x]) + (set! x y) + (set! y tmp))) + +(define tmp 2) +(define other 3) +(swap! tmp other) +(printf "tmp = ~a; other = ~a\n" tmp other) +;; 变量 `tmp` 被重命名为 `tmp_1` +;; 避免名字冲突 +;; (let ([tmp_1 tmp]) +;; (set! tmp other) +;; (set! other tmp_1)) + +;; 但它们仍然会导致错误代码，比如: +(define-syntax-rule (bad-while condition body ...) + (when condition + body ... + (bad-while condition body ...))) +;; 这个宏会挂掉，它产生了一个无限循环，如果你试图去使用它 +;; 编译器会进入死循环 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 10. 契约 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; 契约限制变量从模块中导入 + +(module bank-account racket + (provide (contract-out + [deposit (-> positive? any)] ; 数量一直是正值 + [balance (-> positive?)])) + + (define amount 0) + (define (deposit a) (set! amount (+ amount a))) + (define (balance) amount) + ) + +(require 'bank-account) +(deposit 5) + +(balance) ; => 5 + +;; 客户端尝试存储一个负值时会出错 +;; (deposit -5) ; => deposit: contract violation +;; expected: positive? +;; given: -5 +;; more details.... +``` + +## 进一步阅读 + +想知道更多吗？ 尝试 [Getting Started with Racket](http://docs.racket-lang.org/getting-started/) diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown new file mode 100644 index 00000000..14d38137 --- /dev/null +++ b/zh-cn/ruby-cn.html.markdown @@ -0,0 +1,333 @@ +--- +language: ruby +filename: learnruby-zh.rb +lang: zh-cn +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["lidashuang", "https://github.com/lidashuang"] + - ["ftwbzhao", "https://github.com/ftwbzhao"] +translators: + - ["Lin Xiangyu", "https://github.com/oa414"] +--- + +```ruby +# 这是单行注释 + +=begin +这是多行注释 +没人用这个 +你也不该用 +=end + +# 首先，也是最重要的，所有东西都是对象 + +# 数字是对象 + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# 一些基本的算术符号 +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# 算术符号只是语法糖而已 +# 实际上是调用对象的方法 +1.+(3) #=> 4 +10.* 5 #=> 50 + +# 特殊的值也是对象 +nil # 空 +true # 真 +false # 假 + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# 相等运算符 +1 == 1 #=> true +2 == 1 #=> false + +# 不等运算符 +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# 除了false自己，nil是唯一的值为false的对象 + +!nil #=> true +!false #=> true +!0 #=> false + +# 更多比较 +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# 字符串是对象 + +'I am a string'.class #=> String +"I am a string too".class #=> String + +placeholder = "use string interpolation" +"I can #{placeholder} when using double quoted strings" +#=> "I can use string interpolation when using double quoted strings" + + +# 输出值 +puts "I'm printing!" + +# 变量 +x = 25 #=> 25 +x #=> 25 + +# 注意赋值语句返回了赋的值 +# 这意味着你可以用多重赋值语句 + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# 按照惯例，用 snake_case 作为变量名 +snake_case = true + +# 使用具有描述性的运算符 +path_to_project_root = '/good/name/' +path = '/bad/name/' + +# 符号（Symbols，也是对象) +# 符号是不可变的，内部用整数类型表示的可重用的值。 +# 通常用它代替字符串来有效地表示有意义的值。 + + +:pending.class #=> Symbol + +status = :pending + +status == :pending #=> true + +status == 'pending' #=> false + +status == :approved #=> false + +# 数组 + +# 这是一个数组 +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# 数组可以包含不同类型的元素 + +[1, "hello", false] #=> [1, "hello", false] + +# 数组可以被索引 +# 从前面开始 +array[0] #=> 1 +array[12] #=> nil + +# 像运算符一样，[var]形式的访问 +# 也就是一个语法糖 +# 实际上是调用对象的[] 方法 +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# 从尾部开始 +array[-1] #=> 5 + +# 同时指定开始的位置和长度 +array[2, 3] #=> [3, 4, 5] + +# 或者指定一个范围 +array[1..3] #=> [2, 3, 4] + +# 像这样往数组增加一个元素 +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# 哈希表是Ruby的键值对的基本数据结构 +# 哈希表由大括号定义 +hash = {'color' => 'green', 'number' => 5} + +hash.keys #=> ['color', 'number'] + +# 哈希表可以通过键快速地查询 +hash['color'] #=> 'green' +hash['number'] #=> 5 + +# 查询一个不存在地键将会返回nil +hash['nothing here'] #=> nil + +# 用 #each 方法来枚举哈希表: +hash.each do |k, v| + puts "#{k} is #{v}" +end + +# 从Ruby 1.9开始, 用符号作为键的时候有特别的记号表示: + +new_hash = { defcon: 3, action: true} + +new_hash.keys #=> [:defcon, :action] + +# 小贴士：数组和哈希表都是可枚举的 +# 它们可以共享一些有用的方法，比如each, map, count 等等 + +# 控制流 + +if true + "if statement" +elsif false + "else if, optional" +else + "else, also optional" +end + +for counter in 1..5 + puts "iteration #{counter}" +end +#=> iteration 1 +#=> iteration 2 +#=> iteration 3 +#=> iteration 4 +#=> iteration 5 + +# 然而 +# 没人用for循环 +# 用`each`来代替，就像这样 + +(1..5).each do |counter| + puts "iteration #{counter}" +end +#=> iteration 1 +#=> iteration 2 +#=> iteration 3 +#=> iteration 4 +#=> iteration 5 + +counter = 1 +while counter <= 5 do + puts "iteration #{counter}" + counter += 1 +end +#=> iteration 1 +#=> iteration 2 +#=> iteration 3 +#=> iteration 4 +#=> iteration 5 + +grade = 'B' + +case grade +when 'A' + puts "Way to go kiddo" +when 'B' + puts "Better luck next time" +when 'C' + puts "You can do better" +when 'D' + puts "Scraping through" +when 'F' + puts "You failed!" +else + puts "Alternative grading system, eh?" +end + +# 函数 + +def double(x) + x * 2 +end + +# 函数 (以及所有的方法块) 隐式地返回了最后语句的值 +double(2) #=> 4 + +# 当不存在歧义的时候括号是可有可无的 +double 3 #=> 6 + +double double 3 #=> 12 + +def sum(x,y) + x + y +end + +# 方法的参数通过逗号分隔 +sum 3, 4 #=> 7 + +sum sum(3,4), 5 #=> 12 + +# yield +# 所有的方法都有一个隐式的块参数 +# 可以用yield参数调用 + +def surround + puts "{" + yield + puts "}" +end + +surround { puts 'hello world' } + +# { +# hello world +# } + + +# 用class关键字定义一个类 +class Human + + # 一个类变量，它被这个类地所有实例变量共享 + @@species = "H. sapiens" + + # 构造函数 + def initialize(name, age=0) + # 将参数name的值赋给实例变量@name + @name = name + # 如果没有给出age, 那么会采用参数列表中地默认地值 + @age = age + end + + # 基本的 setter 方法 + def name=(name) + @name = name + end + + # 基本地 getter 方法 + def name + @name + end + + # 一个类方法以self.开头 + # 它可以被类调用，但不能被类的实例调用 + def self.say(msg) + puts "#{msg}" + end + + def species + @@species + end + +end + + +# 类的例子 +jim = Human.new("Jim Halpert") + +dwight = Human.new("Dwight K. Schrute") + +# 让我们来调用一些方法 +jim.species #=> "H. sapiens" +jim.name #=> "Jim Halpert" +jim.name = "Jim Halpert II" #=> "Jim Halpert II" +jim.name #=> "Jim Halpert II" +dwight.species #=> "H. sapiens" +dwight.name #=> "Dwight K. Schrute" + +# 调用对象的方法 +Human.say("Hi") #=> "Hi" + +``` diff --git a/zh-cn/rust-cn.html.markdown b/zh-cn/rust-cn.html.markdown new file mode 100644 index 00000000..17a897df --- /dev/null +++ b/zh-cn/rust-cn.html.markdown @@ -0,0 +1,296 @@ +--- +language: rust +contributors: + - ["P1start", "http://p1start.github.io/"] +translators: + - ["Guangming Mao", "http://maogm.com"] +filename: learnrust-cn.rs +lang: zh-cn +--- + +Rust 是由 Mozilla 研究院开发的编程语言。Rust 将底层的性能控制与高级语言的便利性和安全保障结合在了一起。 + +而 Rust 并不需要一个垃圾回收器或者运行时即可实现这个目的，这使得 Rust 库可以成为一种 C 语言的替代品。 + +Rust 第一版（0.1 版）发布于 2012 年 1 月，3 年以来一直在紧锣密鼓地迭代。 +因为更新太频繁，一般建议使用每夜构建版而不是稳定版，直到最近 1.0 版本的发布。 + +2015 年 3 月 15 日，Rust 1.0 发布，完美向后兼容，最新的每夜构建版提供了缩短编译时间等新特性。 +Rust 采用了持续迭代模型，每 6 周一个发布版。Rust 1.1 beta 版在 1.0 发布时同时发布。 + +尽管 Rust 相对来说是一门底层语言，它提供了一些常见于高级语言的函数式编程的特性。这让 Rust 不仅高效，并且易用。 + +```rust +// 这是注释，单行注释... +/* ...这是多行注释 */ + +/////////////// +// 1. 基础 // +/////////////// + +// 函数 (Functions) +// `i32` 是有符号 32 位整数类型(32-bit signed integers) +fn add2(x: i32, y: i32) -> i32 { + // 隐式返回 (不要分号) + x + y +} + +// 主函数(Main function) +fn main() { + // 数字 (Numbers) // + + // 不可变绑定 + let x: i32 = 1; + + // 整形/浮点型数 后缀 + let y: i32 = 13i32; + let f: f64 = 1.3f64; + + // 类型推导 + // 大部分时间，Rust 编译器会推导变量类型，所以不必把类型显式写出来。 + // 这个教程里面很多地方都显式写了类型，但是只是为了示范。 + // 绝大部分时间可以交给类型推导。 + let implicit_x = 1; + let implicit_f = 1.3; + + // 算术运算 + let sum = x + y + 13; + + // 可变变量 + let mut mutable = 1; + mutable = 4; + mutable += 2; + + // 字符串 (Strings) // + + // 字符串字面量 + let x: &str = "hello world!"; + + // 输出 + println!("{} {}", f, x); // 1.3 hello world + + // 一个 `String` – 在堆上分配空间的字符串 + let s: String = "hello world".to_string(); + + // 字符串分片(slice) - 另一个字符串的不可变视图 + // 基本上就是指向一个字符串的不可变指针，它不包含字符串里任何内容，只是一个指向某个东西的指针 + // 比如这里就是 `s` + let s_slice: &str = &s; + + println!("{} {}", s, s_slice); // hello world hello world + + // 数组 (Vectors/arrays) // + + // 长度固定的数组 (array) + let four_ints: [i32; 4] = [1, 2, 3, 4]; + + // 变长数组 (vector) + let mut vector: Vec<i32> = vec![1, 2, 3, 4]; + vector.push(5); + + // 分片 - 某个数组(vector/array)的不可变视图 + // 和字符串分片基本一样，只不过是针对数组的 + let slice: &[i32] = &vector; + + // 使用 `{:?}` 按调试样式输出 + println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + + // 元组 (Tuples) // + + // 元组是固定大小的一组值，可以是不同类型 + let x: (i32, &str, f64) = (1, "hello", 3.4); + + // 解构 `let` + let (a, b, c) = x; + println!("{} {} {}", a, b, c); // 1 hello 3.4 + + // 索引 + println!("{}", x.1); // hello + + ////////////// + // 2. 类型 (Type) // + ////////////// + + // 结构体（Sturct) + struct Point { + x: i32, + y: i32, + } + + let origin: Point = Point { x: 0, y: 0 }; + + // 匿名成员结构体，又叫“元组结构体”（‘tuple struct’） + struct Point2(i32, i32); + + let origin2 = Point2(0, 0); + + // 基础的 C 风格枚举类型（enum） + enum Direction { + Left, + Right, + Up, + Down, + } + + let up = Direction::Up; + + // 有成员的枚举类型 + enum OptionalI32 { + AnI32(i32), + Nothing, + } + + let two: OptionalI32 = OptionalI32::AnI32(2); + let nothing = OptionalI32::Nothing; + + // 泛型 (Generics) // + + struct Foo<T> { bar: T } + + // 这个在标准库里面有实现，叫 `Option` + enum Optional<T> { + SomeVal(T), + NoVal, + } + + // 方法 (Methods) // + + impl<T> Foo<T> { + // 方法需要一个显式的 `self` 参数 + fn get_bar(self) -> T { + self.bar + } + } + + let a_foo = Foo { bar: 1 }; + println!("{}", a_foo.get_bar()); // 1 + + // 接口（Traits） （其他语言里叫 interfaces 或 typeclasses） // + + trait Frobnicate<T> { + fn frobnicate(self) -> Option<T>; + } + + impl<T> Frobnicate<T> for Foo<T> { + fn frobnicate(self) -> Option<T> { + Some(self.bar) + } + } + + let another_foo = Foo { bar: 1 }; + println!("{:?}", another_foo.frobnicate()); // Some(1) + + /////////////////////////////////// + // 3. 模式匹配 (Pattern matching) // + /////////////////////////////////// + + let foo = OptionalI32::AnI32(1); + match foo { + OptionalI32::AnI32(n) => println!("it’s an i32: {}", n), + OptionalI32::Nothing => println!("it’s nothing!"), + } + + // 高级模式匹配 + struct FooBar { x: i32, y: OptionalI32 } + let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) }; + + match bar { + FooBar { x: 0, y: OptionalI32::AnI32(0) } => + println!("The numbers are zero!"), + FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m => + println!("The numbers are the same"), + FooBar { x: n, y: OptionalI32::AnI32(m) } => + println!("Different numbers: {} {}", n, m), + FooBar { x: _, y: OptionalI32::Nothing } => + println!("The second number is Nothing!"), + } + + /////////////////////////////// + // 4. 流程控制 (Control flow) // + /////////////////////////////// + + // `for` 循环 + let array = [1, 2, 3]; + for i in array.iter() { + println!("{}", i); + } + + // 区间 (Ranges) + for i in 0u32..10 { + print!("{} ", i); + } + println!(""); + // 输出 `0 1 2 3 4 5 6 7 8 9 ` + + // `if` + if 1 == 1 { + println!("Maths is working!"); + } else { + println!("Oh no..."); + } + + // `if` 可以当表达式 + let value = if true { + "good" + } else { + "bad" + }; + + // `while` 循环 + while 1 == 1 { + println!("The universe is operating normally."); + } + + // 无限循环 + loop { + println!("Hello!"); + } + + //////////////////////////////////////////////// + // 5. 内存安全和指针 (Memory safety & pointers) // + //////////////////////////////////////////////// + + // 独占指针 (Owned pointer) - 同一时刻只能有一个对象能“拥有”这个指针 + // 意味着 `Box` 离开他的作用域后，会被安全地释放 + let mut mine: Box<i32> = Box::new(3); + *mine = 5; // 解引用 + // `now_its_mine` 获取了 `mine` 的所有权。换句话说，`mine` 移动 (move) 了 + let mut now_its_mine = mine; + *now_its_mine += 2; + + println!("{}", now_its_mine); // 7 + // println!("{}", mine); // 编译报错，因为现在 `now_its_mine` 独占那个指针 + + // 引用 (Reference) – 引用其他数据的不可变指针 + // 当引用指向某个值，我们称为“借用”这个值，因为是被不可变的借用，所以不能被修改，也不能移动 + // 借用一直持续到生命周期结束，即离开作用域 + let mut var = 4; + var = 3; + let ref_var: &i32 = &var; + + println!("{}", var); //不像 `box`, `var` 还可以继续使用 + println!("{}", *ref_var); + // var = 5; // 编译报错，因为 `var` 被借用了 + // *ref_var = 6; // 编译报错，因为 `ref_var` 是不可变引用 + + // 可变引用 (Mutable reference) + // 当一个变量被可变地借用时，也不可使用 + let mut var2 = 4; + let ref_var2: &mut i32 = &mut var2; + *ref_var2 += 2; + + println!("{}", *ref_var2); // 6 + // var2 = 2; // 编译报错，因为 `var2` 被借用了 +} +``` + +## 更深入的资料 + +Rust 还有很多很多其他内容 - 这只是 Rust 最基本的功能，帮助你了解 Rust 里面最重要的东西。 +如果想深入学习 Rust，可以去读 +[The Rust Programming Language](http://doc.rust-lang.org/book/index.html) +或者上 reddit [/r/rust](http://reddit.com/r/rust) 订阅。 +同时 irc.mozilla.org 的 #rust 频道上的小伙伴们也非常欢迎新来的朋友。 + +你可以在这个在线编译器 [Rust playpen](http://play.rust-lang.org) 上尝试 Rust 的一些特性 +或者上[官方网站](http://rust-lang.org). diff --git a/zh-cn/scala-cn.html.markdown b/zh-cn/scala-cn.html.markdown new file mode 100644 index 00000000..508dd58e --- /dev/null +++ b/zh-cn/scala-cn.html.markdown @@ -0,0 +1,616 @@ +--- +language: Scala +filename: learnscala-zh.scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra", "http://dbousamra.github.com"] + - ["Geoff Liu", "http://geoffliu.me"] +translators: + - ["Peiyong Lin", ""] + - ["Jinchang Ye", "http://github.com/alwayswithme"] + - ["Guodong Qu", "https://github.com/jasonqu"] +lang: zh-cn +--- + +Scala - 一门可拓展的语言 + +```scala + +/* + 自行设置: + + 1) 下载 Scala - http://www.scala-lang.org/downloads + 2) unzip/untar 到您喜欢的地方，并把 bin 子目录添加到 path 环境变量 + 3) 在终端输入 scala，启动 Scala 的 REPL，您会看到提示符： + + scala> + + 这就是所谓的 REPL (读取-求值-输出循环，英语： Read-Eval-Print Loop)， + 您可以在其中输入合法的表达式，结果会被打印。 + 在教程中我们会进一步解释 Scala 文件是怎样的，但现在先了解一点基础。 +*/ + + +///////////////////////////////////////////////// +// 1. 基础 +///////////////////////////////////////////////// + +// 单行注释开始于两个斜杠 + +/* + 多行注释，如您之前所见，看起来像这样 +*/ + +// 打印并强制换行 +println("Hello world!") +println(10) + +// 没有强制换行的打印 +print("Hello world") + +// 通过 var 或者 val 来声明变量 +// val 声明是不可变的，var 声明是可修改的。不可变性是好事。 +val x = 10 // x 现在是 10 +x = 20 // 错误: 对 val 声明的变量重新赋值 +var y = 10 +y = 20 // y 现在是 20 + +/* + Scala 是静态语言，但注意上面的声明方式，我们没有指定类型。 + 这是因为类型推导的语言特性。大多数情况， Scala 编译器可以推测变量的类型， + 所以您不需要每次都输入。可以像这样明确声明变量类型： +*/ +val z: Int = 10 +val a: Double = 1.0 + +// 注意从 Int 到 Double 的自动转型，结果是 10.0, 不是 10 +val b: Double = 10 + +// 布尔值 +true +false + +// 布尔操作 +!true // false +!false // true +true == false // false +10 > 5 // true + +// 数学运算像平常一样 +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 +6 / 4 // 1 +6.0 / 4 // 1.5 + + +// 在 REPL 计算一个表达式会返回给您结果的类型和值 + +1 + 7 + +/* 上行的结果是： + + scala> 1 + 7 + res29: Int = 8 + + 这意味着计算 1 + 7 的结果是一个 Int 类型的对象，其值为 8 + + 注意 "res29" 是一个连续生成的变量名，用以存储您输入的表达式结果， + 您看到的输出可能不一样。 +*/ + +"Scala strings are surrounded by double quotes" +'a' // Scala 的字符 +// '不存在单引号字符串' <= 这会导致错误 + +// String 有常见的 Java 字符串方法 +"hello world".length +"hello world".substring(2, 6) +"hello world".replace("C", "3") + +// 也有一些额外的 Scala 方法，另请参见：scala.collection.immutable.StringOps +"hello world".take(5) +"hello world".drop(5) + +// 字符串改写：留意前缀 "s" +val n = 45 +s"We have $n apples" // => "We have 45 apples" + +// 在要改写的字符串中使用表达式也是可以的 +val a = Array(11, 9, 6) +s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old." +s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples." +s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" + +// 添加 "f" 前缀对要改写的字符串进行格式化 +f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" +f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" + +// 未处理的字符串，忽略特殊字符。 +raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." + +// 一些字符需要转义，比如字符串中的双引号 +"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" + +// 三个双引号可以使字符串跨越多行，并包含引号 +val html = """<form id="daform"> + <p>Press belo', Joe</p> + <input type="submit"> + </form>""" + + +///////////////////////////////////////////////// +// 2. 函数 +///////////////////////////////////////////////// + +// 函数可以这样定义: +// +// def functionName(args...): ReturnType = { body... } +// +// 如果您以前学习过传统的编程语言，注意 return 关键字的省略。 +// 在 Scala 中， 函数代码块最后一条表达式就是返回值。 +def sumOfSquares(x: Int, y: Int): Int = { + val x2 = x * x + val y2 = y * y + x2 + y2 +} + +// 如果函数体是单行表达式，{ } 可以省略： +def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y + +// 函数调用的语法是熟知的： +sumOfSquares(3, 4) // => 25 + +// 在多数情况下 (递归函数是需要注意的例外), 函数返回值可以省略， +// 变量所用的类型推导一样会应用到函数返回值中： +def sq(x: Int) = x * x // 编译器会推断得知返回值是 Int + +// 函数可以有默认参数 +def addWithDefault(x: Int, y: Int = 5) = x + y +addWithDefault(1, 2) // => 3 +addWithDefault(1) // => 6 + + +// 匿名函数是这样的： +(x:Int) => x * x + +// 和 def 不同，如果语义清晰，匿名函数的参数类型也可以省略。 +// 类型 "Int => Int" 意味着这个函数接收一个 Int 并返回一个 Int。 +val sq: Int => Int = x => x * x + +// 匿名函数的调用也是类似的： +sq(10) // => 100 + +// 如果您的匿名函数中每个参数仅使用一次， +// Scala 提供一个更简洁的方式来定义他们。这样的匿名函数极为常见， +// 在数据结构部分会明显可见。 +val addOne: Int => Int = _ + 1 +val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) + +addOne(5) // => 6 +weirdSum(2, 4) // => 16 + + +// return 关键字是存在的，但它只从最里面包裹了 return 的 def 函数中返回。 +// 警告： 在 Scala 中使用 return 容易出错，应该避免使用。 +// 在匿名函数中没有效果，例如： +def foo(x: Int): Int = { + val anonFunc: Int => Int = { z => + if (z > 5) + return z // 这一行令 z 成为 foo 函数的返回值！ + else + z + 2 // 这一行是 anonFunc 函数的返回值 + } + anonFunc(x) // 这一行是 foo 函数的返回值 +} + +/* + * 译者注：此处是指匿名函数中的 return z 成为最后执行的语句， + * 在 anonFunc(x) 下面的表达式（假设存在）不再执行。如果 anonFunc + * 是用 def 定义的函数， return z 仅返回到 anonFunc(x) ， + * 在 anonFunc(x) 下面的表达式（假设存在）会继续执行。 + */ + + +///////////////////////////////////////////////// +// 3. 控制语句 +///////////////////////////////////////////////// + +1 to 5 +val r = 1 to 5 +r.foreach( println ) + +r foreach println +// 附注： Scala 对点和括号的要求想当宽松，注意其规则是不同的。 +// 这有助于写出读起来像英语的 DSL(领域特定语言) 和 API(应用编程接口)。 + +(5 to 1 by -1) foreach ( println ) + +// while 循环 +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + +while (i < 10) { println("i " + i); i+=1 } // 没错，再执行一次，发生了什么？为什么？ + +i // 显示 i 的值。注意 while 是经典的循环方式，它连续执行并改变循环中的变量。 + // while 执行很快，比 Java 的循环快，但像上面所看到的那样用组合子和推导式 + // 更易于理解和并行化。 + +// do while 循环 +do { + println("x is still less than 10"); + x += 1 +} while (x < 10) + +// Scala 中尾递归是一种符合语言习惯的递归方式。 +// 递归函数需要清晰的返回类型，编译器不能推断得知。 +// 这是一个 Unit。 +def showNumbersInRange(a:Int, b:Int):Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} +showNumbersInRange(1,14) + + +// 条件语句 + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + + +///////////////////////////////////////////////// +// 4. 数据结构 +///////////////////////////////////////////////// + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // 抛出异常 + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // 抛出异常 + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* 这里查看 map 的文档 - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + * 并确保你会阅读 + */ + + +// 元组 + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// 为什么有这个？ +val divideInts = (x:Int, y:Int) => (x / y, x % y) + +divideInts(10,3) // 函数 divideInts 同时返回结果和余数 + +// 要读取元组的元素，使用 _._n，n是从1开始的元素索引 +val d = divideInts(10,3) + +d._1 + +d._2 + + +///////////////////////////////////////////////// +// 5. 面向对象编程 +///////////////////////////////////////////////// + +/* + 旁白: 教程中到现在为止我们所做的一切只是简单的表达式（值，函数等）。 + 这些表达式可以输入到命令行解释器中作为快速测试，但它们不能独立存在于 Scala + 文件。举个例子，您不能在 Scala 文件上简单的写上 "val x = 5"。相反 Scala 文件 + 允许的顶级结构是： + + - objects + - classes + - case classes + - traits + + 现在来解释这些是什么。 +*/ + +// 类和其他语言的类相似，构造器参数在类名后声明，初始化在类结构体中完成。 +class Dog(br: String) { + // 构造器代码在此 + var breed: String = br + + // 定义名为 bark 的方法，返回字符串 + def bark = "Woof, woof!" + + // 值和方法作用域假定为 public。"protected" 和 "private" 关键字也是可用的。 + private def sleep(hours: Int) = + println(s"I'm sleeping for $hours hours") + + // 抽象方法是没有方法体的方法。如果取消下面那行注释，Dog 类必须被声明为 abstract + // abstract class Dog(...) { ... } + // def chaseAfter(what: String): String +} + +val mydog = new Dog("greyhound") +println(mydog.breed) // => "greyhound" +println(mydog.bark) // => "Woof, woof!" + + +// "object" 关键字创造一种类型和该类型的单例。 +// Scala 的 class 常常也含有一个 “伴生对象”，class 中包含每个实例的行为，所有实例 +// 共用的行为则放入 object 中。两者的区别和其他语言中类方法和静态方法类似。 +// 请注意 object 和 class 可以同名。 +object Dog { + def allKnownBreeds = List("pitbull", "shepherd", "retriever") + def createDog(breed: String) = new Dog(breed) +} + + +// Case 类是有额外内建功能的类。Scala 初学者常遇到的问题之一便是何时用类 +// 和何时用 case 类。界线比较模糊，但通常类倾向于封装，多态和行为。类中的值 +// 的作用域一般为 private ， 只有方向是暴露的。case 类的主要目的是放置不可变 +// 数据。它们通常只有几个方法，且方法几乎没有副作用。 +case class Person(name: String, phoneNumber: String) + +// 创造新实例，注意 case 类不需要使用 "new" 关键字 +val george = Person("George", "1234") +val kate = Person("Kate", "4567") + +// 使用 case 类，您可以轻松得到一些功能，像 getters: +george.phoneNumber // => "1234" + +// 每个字段的相等性比较（无需覆盖 .equals） +Person("George", "1234") == Person("Kate", "1236") // => false + +// 简单的拷贝方式 +// otherGeorge == Person("george", "9876") +val otherGeorge = george.copy(phoneNumber = "9876") + +// 还有很多。case 类同时可以用于模式匹配，接下来会看到。 + + +// 敬请期待 Traits ！ + + +///////////////////////////////////////////////// +// 6. 模式匹配 +///////////////////////////////////////////////// + +// 模式匹配是一个强大和常用的 Scala 特性。这是用模式匹配一个 case 类的例子。 +// 附注：不像其他语言， Scala 的 case 不需要 break， 其他语言中 switch 语句的 +// fall-through 现象不会发生。 + +def matchPerson(person: Person): String = person match { + // Then you specify the patterns: + case Person("George", number) => "We found George! His number is " + number + case Person("Kate", number) => "We found Kate! Her number is " + number + case Person(name, number) => "We matched someone : " + name + ", phone : " + number +} + +val email = "(.*)@(.*)".r // 定义下一个例子会用到的正则 + +// 模式匹配看起来和 C语言家族的 switch 语句相似，但更为强大。 +// Scala 中您可以匹配很多东西： +def matchEverything(obj: Any): String = obj match { + // 匹配值： + case "Hello world" => "Got the string Hello world" + + // 匹配类型： + case x: Double => "Got a Double: " + x + + // 匹配时指定条件 + case x: Int if x > 10000 => "Got a pretty big number!" + + // 像之前一样匹配 case 类： + case Person(name, number) => s"Got contact info for $name!" + + // 匹配正则表达式： + case email(name, domain) => s"Got email address $name@$domain" + + // 匹配元组： + case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" + + // 匹配数据结构： + case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" + + // 模式可以嵌套 + case List(List((1, 2,"YAY"))) => "Got a list of list of tuple" +} + +// 事实上，你可以对任何有 "unapply" 方法的对象进行模式匹配。 +// 这个特性如此强大以致于 Scala 允许定义一个函数作为模式匹配： +val patternFunc: Person => String = { + case Person("George", number) => s"George's number: $number" + case Person(name, number) => s"Random person's number: $number" +} + + +///////////////////////////////////////////////// +// 7. 函数式编程 +///////////////////////////////////////////////// + +// Scala 允许方法和函数作为其他方法和函数的参数和返回值。 + +val add10: Int => Int = _ + 10 // 一个接受一个 Int 类型参数并返回一个 Int 类型值的函数 +List(1, 2, 3) map add10 // List(11, 12, 13) - add10 被应用到每一个元素 + +// 匿名函数可以被使用来代替有命名的函数： +List(1, 2, 3) map (x => x + 10) + +// 如果匿名函数只有一个参数可以用下划线作为变量 +List(1, 2, 3) map (_ + 10) + +// 如果您所应用的匿名块和匿名函数都接受一个参数，那么你甚至可以省略下划线 +List("Dom", "Bob", "Natalia") foreach println + + +// 组合子 + +// 译注: val sq: Int => Int = x => x * x +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + +// filter 函数接受一个 predicate （函数根据条件 A 返回 Boolean）并选择 +// 所有满足 predicate 的元素 +List(1, 2, 3) filter (_ > 2) // List(3) +case class Person(name:String, age:Int) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + + +// Scala 的 foreach 方法定义在某些集合中，接受一个函数并返回 Unit （void 方法） +// 另请参见： +// http://www.scala-lang.org/api/current/index.html#scala.collection.IterableLike@foreach(f:A=>Unit):Unit +val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + +// For 推导式 + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + +/* 注意，这些不是 for 循环，for 循环的语义是‘重复’，然而 for 推导式定义 + 两个数据集合的关系。 */ + + +///////////////////////////////////////////////// +// 8. 隐式转换 +///////////////////////////////////////////////// + +/* 警告 警告: 隐式转换是 Scala 中一套强大的特性，因此容易被滥用。 + * Scala 初学者在理解它们的工作原理和最佳实践之前，应抵制使用它的诱惑。 + * 我们加入这一章节仅因为它们在 Scala 的库中太过常见，导致没有用隐式转换的库 + * 就不可能做有意义的事情。这章节主要让你理解和使用隐式转换，而不是自己声明。 + */ + +// 可以通过 "implicit" 声明任何值（val, 函数，对象等）为隐式值， +// 请注意这些例子中，我们用到第5部分的 Dog 类。 +implicit val myImplicitInt = 100 +implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed) + +// implicit 关键字本身不改变值的行为，所以上面的值可以照常使用。 +myImplicitInt + 2 // => 102 +myImplicitFunction("Pitbull").breed // => "Golden Pitbull" + +// 区别在于，当另一段代码“需要”隐式值时，这些值现在有资格作为隐式值。 +// 一种情况是隐式函数参数。 +def sendGreetings(toWhom: String)(implicit howMany: Int) = + s"Hello $toWhom, $howMany blessings to you and yours!" + +// 如果提供值给 “howMany”，函数正常运行 +sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" + +// 如果省略隐式参数，会传一个和参数类型相同的隐式值， +// 在这个例子中， 是 “myImplicitInt": +sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" + +// 隐式的函数参数使我们可以模拟其他函数式语言的 type 类（type classes）。 +// 它经常被用到所以有特定的简写。这两行代码是一样的： +def foo[T](implicit c: C[T]) = ... +def foo[T : C] = ... + +// 编译器寻找隐式值另一种情况是你调用方法时 +// obj.method(...) +// 但 "obj" 没有一个名为 "method" 的方法。这样的话，如果有一个参数类型为 A +// 返回值类型为 B 的隐式转换，obj 的类型是 A，B 有一个方法叫 "method" ，这样 +// 转换就会被应用。所以作用域里有上面的 myImplicitFunction, 我们可以这样做： +"Retriever".breed // => "Golden Retriever" +"Sheperd".bark // => "Woof, woof!" + +// 这里字符串先被上面的函数转换为 Dog 对象，然后调用相应的方法。 +// 这是相当强大的特性，但再次提醒，请勿轻率使用。 +// 事实上，当你定义上面的隐式函数时，编译器会作出警告，除非你真的了解 +// 你正在做什么否则不要使用。 + + +///////////////////////////////////////////////// +// 9. 杂项 +///////////////////////////////////////////////// + +// 导入类 +import scala.collection.immutable.List + +// 导入所有子包 +import scala.collection.immutable._ + +// 一条语句导入多个类 +import scala.collection.immutable.{List, Map} + +// 使用 ‘=>’ 对导入进行重命名 +import scala.collection.immutable.{ List => ImmutableList } + +// 导入所有类，排除其中一些。下面的语句排除了 Map 和 Set： +import scala.collection.immutable.{Map => _, Set => _, _} + +// 在 Scala 文件用 object 和单一的 main 方法定义程序入口： +object Application { + def main(args: Array[String]): Unit = { + // stuff goes here. + } +} + +// 文件可以包含多个 class 和 object，用 scalac 编译源文件 + + + + +// 输入和输出 + +// 按行读文件 +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// 用 Java 的 PrintWriter 写文件 +val writer = new PrintWriter("myfile.txt") +writer.write("Writing line for line" + util.Properties.lineSeparator) +writer.write("Another line here" + util.Properties.lineSeparator) +writer.close() + +``` + +## 更多的资源 + +[为没耐心的人准备的 Scala](http://horstmann.com/scala/) + +[Twitter Scala school](http://twitter.github.io/scala_school/) + +[The Scala documentation](http://www.scala-lang.org/documentation/) + +[在浏览器尝试 Scala](http://scalatutorials.com/tour/) + +加入 [Scala 用户组](https://groups.google.com/forum/#!forum/scala-user) diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown new file mode 100644 index 00000000..28001e3f --- /dev/null +++ b/zh-cn/swift-cn.html.markdown @@ -0,0 +1,591 @@ +--- +language: swift +filename: learnswift-cn.swift +contributors: + - ["Grant Timmerman", "http://github.com/grant"] +translators: + - ["Xavier Yao", "http://github.com/xavieryao"] + - ["Joey Huang", "http://github.com/kamidox"] +lang: zh-cn +--- + +Swift 是 Apple 开发的用于 iOS 和 OS X 开发的编程语言。Swift 于2014年 Apple WWDC （全球开发者大会）中被引入，用以与 Objective-C 共存，同时对错误代码更具弹性。Swift 由 Xcode 6 beta 中包含的 LLVM 编译器编译。 + +Swift 的官方语言教程 [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) 可以从 iBooks 免费下载. + +亦可参阅：Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html) ——一个完整的Swift 教程 + +```swift +// 导入外部模块 +import UIKit + +// +// MARK: 基础 +// + +// XCODE 支持给注释代码作标记，这些标记会列在 XCODE 的跳转栏里，支持的标记为 +// MARK: 普通标记 +// TODO: TODO 标记 +// FIXME: FIXME 标记 + +println("Hello, world") + +// 变量 (var) 的值设置后可以随意改变 +// 常量 (let) 的值设置后不能改变 +var myVariable = 42 +let øπΩ = "value" // 可以支持 unicode 变量名 +let π = 3.1415926 +let myConstant = 3.1415926 +let explicitDouble: Double = 70 // 明确指定变量类型为 Double ，否则编译器将自动推断变量类型 +let weak = "keyword"; let override = "another keyword" // 语句之间可以用分号隔开，语句未尾不需要分号 +let intValue = 0007 // 7 +let largeIntValue = 77_000 // 77000 +let label = "some text " + String(myVariable) // 类型转换 +let piText = "Pi = \(π), Pi 2 = \(π * 2)" // 格式化字符串 + +// 条件编译 +// 使用 -D 定义编译开关 +#if false + println("Not printed") + let buildValue = 3 +#else + let buildValue = 7 +#endif +println("Build value: \(buildValue)") // Build value: 7 + +/* + Optionals 是 Swift 的新特性，它允许你存储两种状态的值给 Optional 变量：有效值或 None + + Swift 要求所有的 Optinal 属性都必须有明确的值，如果为空，则必须明确设定为 nil + + Optional<T> 是个枚举类型 +*/ +var someOptionalString: String? = "optional" // 可以是 nil +// 下面的语句和上面完全等价，上面的写法更推荐，因为它更简洁，问号 (?) 是 Swift 提供的语法糖 +var someOptionalString2: Optional<String> = "optional" + +if someOptionalString != nil { + // 变量不为空 + if someOptionalString!.hasPrefix("opt") { + println("has the prefix") + } + + let empty = someOptionalString?.isEmpty +} +someOptionalString = nil + +// 显式解包 optional 变量 +var unwrappedString: String! = "Value is expected." +// 下面语句和上面完全等价，感叹号 (!) 是个后缀运算符，这也是个语法糖 +var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected." + +if let someOptionalStringConstant = someOptionalString { + // 由于变量 someOptinalString 有值，不为空，所以 if 条件为真 + if !someOptionalStringConstant.hasPrefix("ok") { + // does not have the prefix + } +} + +// Swift 支持可保存任何数据类型的变量 +// AnyObject == id +// 和 Objective-C `id` 不一样, AnyObject 可以保存任何类型的值 (Class, Int, struct, 等) +var anyObjectVar: AnyObject = 7 +anyObjectVar = "Changed value to a string, not good practice, but possible." + +/* + 这里是注释 + + /* + 支持嵌套的注释 + */ +*/ + + +// +// Mark: 数组与字典（关联数组） +// + +/* + Array 和 Dictionary 是结构体，不是类，他们作为函数参数时，是用值传递而不是指针传递。 + 可以用 `var` 和 `let` 来定义变量和常量。 +*/ + +// Array +var shoppingList = ["catfish", "water", "lemons"] +shoppingList[1] = "bottle of water" +let emptyArray = [String]() // 使用 let 定义常量，此时 emptyArray 数组不能添加或删除内容 +let emptyArray2 = Array<String>() // 与上一语句等价，上一语句更常用 +var emptyMutableArray = [String]() // 使用 var 定义变量，可以向 emptyMutableArray 添加数组元素 + +// 字典 +var occupations = [ + "Malcolm": "Captain", + "kaylee": "Mechanic" +] +occupations["Jayne"] = "Public Relations" // 修改字典，如果 key 不存在，自动添加一个字典元素 +let emptyDictionary = [String: Float]() // 使用 let 定义字典常量，字典常量不能修改里面的值 +let emptyDictionary2 = Dictionary<String, Float>() // 与上一语句类型等价，上一语句更常用 +var emptyMutableDictionary = [String: Float]() // 使用 var 定义字典变量 + + +// +// MARK: 控制流 +// + +// 数组的 for 循环 +let myArray = [1, 1, 2, 3, 5] +for value in myArray { + if value == 1 { + println("One!") + } else { + println("Not one!") + } +} + +// 字典的 for 循环 +var dict = ["one": 1, "two": 2] +for (key, value) in dict { + println("\(key): \(value)") +} + +// 区间的 loop 循环：其中 `...` 表示闭环区间，即[-1, 3]；`..<` 表示半开闭区间，即[-1,3) +for i in -1...shoppingList.count { + println(i) +} +shoppingList[1...2] = ["steak", "peacons"] +// 可以使用 `..<` 来去掉最后一个元素 + +// while 循环 +var i = 1 +while i < 1000 { + i *= 2 +} + +// do-while 循环 +do { + println("hello") +} while 1 == 2 + +// Switch 语句 +// Swift 里的 Switch 语句功能异常强大，结合枚举类型，可以实现非常简洁的代码，可以把 switch 语句想象成 `if` 的语法糖 +// 它支持字符串，类实例或原生数据类型 (Int, Double, etc) +let vegetable = "red pepper" +switch vegetable { +case "celery": + let vegetableComment = "Add some raisins and make ants on a log." +case "cucumber", "watercress": + let vegetableComment = "That would make a good tea sandwich." +case let localScopeValue where localScopeValue.hasSuffix("pepper"): + let vegetableComment = "Is it a spicy \(localScopeValue)?" +default: // 在 Swift 里，switch 语句的 case 必须处理所有可能的情况，如果 case 无法全部处理，则必须包含 default语句 + let vegetableComment = "Everything tastes good in soup." +} + + +// +// MARK: 函数 +// + +// 函数是一个 first-class 类型，他们可以嵌套，可以作为函数参数传递 + +// 函数文档可使用 reStructedText 格式直接写在函数的头部 +/** + A greet operation + + - A bullet in docs + - Another bullet in the docs + + :param: name A name + :param: day A day + :returns: A string containing the name and day value. +*/ +func greet(name: String, day: String) -> String { + return "Hello \(name), today is \(day)." +} +greet("Bob", "Tuesday") + +// 函数参数前带 `#` 表示外部参数名和内部参数名使用同一个名称。 +// 第二个参数表示外部参数名使用 `externalParamName` ，内部参数名使用 `localParamName` +func greet2(#requiredName: String, externalParamName localParamName: String) -> String { + return "Hello \(requiredName), the day is \(localParamName)" +} +greet2(requiredName:"John", externalParamName: "Sunday") // 调用时，使用命名参数来指定参数的值 + +// 函数可以通过元组 (tuple) 返回多个值 +func getGasPrices() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let pricesTuple = getGasPrices() +let price = pricesTuple.2 // 3.79 +// 通过下划线 (_) 来忽略不关心的值 +let (_, price1, _) = pricesTuple // price1 == 3.69 +println(price1 == pricesTuple.1) // true +println("Gas price: \(price)") + +// 可变参数 +func setup(numbers: Int...) { + // 可变参数是个数组 + let number = numbers[0] + let argCount = numbers.count +} + +// 函数变量以及函数作为返回值返回 +func makeIncrementer() -> (Int -> Int) { + func addOne(number: Int) -> Int { + return 1 + number + } + return addOne +} +var increment = makeIncrementer() +increment(7) + +// 强制进行指针传递 (引用传递)，使用 `inout` 关键字修饰函数参数 +func swapTwoInts(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +swapTwoInts(&someIntA, &someIntB) +println(someIntB) // 7 + + +// +// MARK: 闭包 +// +var numbers = [1, 2, 6] + +// 函数是闭包的一个特例 + +// 闭包实例 +// `->` 分隔了闭包的参数和返回值 +// `in` 分隔了闭包头 (包括参数及返回值) 和闭包体 +// 下面例子中，`map` 的参数是一个函数类型，它的功能是把数组里的元素作为参数，逐个调用 `map` 参数传递进来的函数。 +numbers.map({ + (number: Int) -> Int in + let result = 3 * number + return result +}) + +// 当闭包的参数类型和返回值都是己知的情况下，且只有一个语句作为其返回值时，我们可以简化闭包的写法 +numbers = numbers.map({ number in 3 * number }) +// 我们也可以使用 $0, $1 来指代第 1 个，第 2 个参数，上面的语句最终可简写为如下形式 +// numbers = numbers.map({ $0 * 3 }) + +print(numbers) // [3, 6, 18] + +// 简洁的闭包 +numbers = sorted(numbers) { $0 > $1 } +// 函数的最后一个参数可以放在括号之外，上面的语句是这个语句的简写形式 +// numbers = sorted(numbers, { $0 > $1 }) + +print(numbers) // [18, 6, 3] + +// 超级简洁的闭包，因为 `<` 是个操作符函数 +numbers = sorted(numbers, < ) + +print(numbers) // [3, 6, 18] + + +// +// MARK: 结构体 +// + +// 结构体和类非常类似，可以有属性和方法 + +struct NamesTable { + let names = [String]() + + // 自定义下标运算符 + subscript(index: Int) -> String { + return names[index] + } +} + +// 结构体有一个自动生成的隐含的命名构造函数 +let namesTable = NamesTable(names: ["Me", "Them"]) +let name = namesTable[1] +println("Name is \(name)") // Name is Them + +// +// MARK: 类 +// + +// 类和结构体的有三个访问控制级别，他们分别是 internal (默认), public, private +// internal: 模块内部可以访问 +// public: 其他模块可以访问 +// private: 只有定义这个类或结构体的源文件才能访问 + +public class Shape { + public func getArea() -> Int { + return 0; + } +} + +// 类的所有方法和属性都是 public 的 +// 如果你只是需要把数据保存在一个结构化的实例里面，应该用结构体 + +internal class Rect: Shape { + // 值属性 (Stored properties) + var sideLength: Int = 1 + + // 计算属性 (Computed properties) + private var perimeter: Int { + get { + return 4 * sideLength + } + set { + // `newValue` 是个隐含的变量，它表示将要设置进来的新值 + sideLength = newValue / 4 + } + } + + // 延时加载的属性，只有这个属性第一次被引用时才进行初始化，而不是定义时就初始化 + // subShape 值为 nil ，直到 subShape 第一次被引用时才初始化为一个 Rect 实例 + lazy var subShape = Rect(sideLength: 4) + + // 监控属性值的变化。 + // 当我们需要在属性值改变时做一些事情，可以使用 `willSet` 和 `didSet` 来设置监控函数 + // `willSet`: 值改变之前被调用 + // `didSet`: 值改变之后被调用 + var identifier: String = "defaultID" { + // `willSet` 的参数是即将设置的新值，参数名可以指定，如果没有指定，就是 `newValue` + willSet(someIdentifier) { + println(someIdentifier) + } + // `didSet` 的参数是已经被覆盖掉的旧的值，参数名也可以指定，如果没有指定，就是 `oldValue` + didSet { + println(oldValue) + } + } + + // 命名构造函数 (designated inits)，它必须初始化所有的成员变量， + // 然后调用父类的命名构造函数继续初始化父类的所有变量。 + init(sideLength: Int) { + self.sideLength = sideLength + // 必须显式地在构造函数最后调用父类的构造函数 super.init + super.init() + } + + func shrink() { + if sideLength > 0 { + --sideLength + } + } + + // 函数重载使用 override 关键字 + override func getArea() -> Int { + return sideLength * sideLength + } +} + +// 类 `Square` 从 `Rect` 继承 +class Square: Rect { + // 便捷构造函数 (convenience inits) 是调用自己的命名构造函数 (designated inits) 的构造函数 + // Square 自动继承了父类的命名构造函数 + convenience init() { + self.init(sideLength: 5) + } + // 关于构造函数的继承，有以下几个规则： + // 1. 如果你没有实现任何命名构造函数，那么你就继承了父类的所有命名构造函数 + // 2. 如果你重载了父类的所有命名构造函数，那么你就自动继承了所有的父类快捷构造函数 + // 3. 如果你没有实现任何构造函数，那么你继承了父类的所有构造函数，包括命名构造函数和便捷构造函数 +} + +var mySquare = Square() +println(mySquare.getArea()) // 25 +mySquare.shrink() +println(mySquare.sideLength) // 4 + +// 类型转换 +let aShape = mySquare as Shape + +// 使用三个等号来比较是不是同一个实例 +if mySquare === aShape { + println("Yep, it's mySquare") +} + +class Circle: Shape { + var radius: Int + override func getArea() -> Int { + return 3 * radius * radius + } + + // optional 构造函数，可能会返回 nil + init?(radius: Int) { + self.radius = radius + super.init() + + if radius <= 0 { + return nil + } + } +} + +// 根据 Swift 类型推断，myCircle 是 Optional<Circle> 类型的变量 +var myCircle = Circle(radius: 1) +println(myCircle?.getArea()) // Optional(3) +println(myCircle!.getArea()) // 3 +var myEmptyCircle = Circle(radius: -1) +println(myEmptyCircle?.getArea()) // "nil" +if let circle = myEmptyCircle { + // 此语句不会输出，因为 myEmptyCircle 变量值为 nil + println("circle is not nil") +} + + +// +// MARK: 枚举 +// + +// 枚举可以像类一样，拥有方法 + +enum Suit { + case Spades, Hearts, Diamonds, Clubs + func getIcon() -> String { + switch self { + case .Spades: return "♤" + case .Hearts: return "♡" + case .Diamonds: return "♢" + case .Clubs: return "♧" + } + } +} + +// 当变量类型明确指定为某个枚举类型时，赋值时可以省略枚举类型 +var suitValue: Suit = .Hearts + +// 非整型的枚举类型需要在定义时赋值 +enum BookName: String { + case John = "John" + case Luke = "Luke" +} +println("Name: \(BookName.John.rawValue)") + +// 与特定数据类型关联的枚举 +enum Furniture { + // 和 Int 型数据关联的枚举记录 + case Desk(height: Int) + // 和 String, Int 关联的枚举记录 + case Chair(brand: String, height: Int) + + func description() -> String { + switch self { + case .Desk(let height): + return "Desk with \(height) cm" + case .Chair(let brand, let height): + return "Chair of \(brand) with \(height) cm" + } + } +} + +var desk: Furniture = .Desk(height: 80) +println(desk.description()) // "Desk with 80 cm" +var chair = Furniture.Chair(brand: "Foo", height: 40) +println(chair.description()) // "Chair of Foo with 40 cm" + + +// +// MARK: 协议 +// 与 Java 的 interface 类似 +// + +// 协议可以让遵循同一协议的类型实例拥有相同的属性，方法，类方法，操作符或下标运算符等 +// 下面代码定义一个协议，这个协议包含一个名为 enabled 的计算属性且包含 buildShape 方法 +protocol ShapeGenerator { + var enabled: Bool { get set } + func buildShape() -> Shape +} + +// 协议声明时可以添加 @objc 前缀，添加 @objc 前缀后， +// 可以使用 is, as, as? 等来检查协议兼容性 +// 需要注意，添加 @objc 前缀后，协议就只能被类来实现， +// 结构体和枚举不能实现加了 @objc 的前缀 +// 只有添加了 @objc 前缀的协议才能声明 optional 方法 +// 一个类实现一个带 optional 方法的协议时，可以实现或不实现这个方法 +// optional 方法可以使用 optional 规则来调用 +@objc protocol TransformShape { + optional func reshaped() + optional func canReshape() -> Bool +} + +class MyShape: Rect { + var delegate: TransformShape? + + func grow() { + sideLength += 2 + + // 在 optional 属性，方法或下标运算符后面加一个问号，可以优雅地忽略 nil 值，返回 nil。 + // 这样就不会引起运行时错误 (runtime error) + if let allow = self.delegate?.canReshape?() { + // 注意语句中的问号 + self.delegate?.reshaped?() + } + } +} + + +// +// MARK: 其它 +// + +// 扩展: 给一个已经存在的数据类型添加功能 + +// 给 Square 类添加 `Printable` 协议的实现，现在其支持 `Printable` 协议 +extension Square: Printable { + var description: String { + return "Area: \(self.getArea()) - ID: \(self.identifier)" + } +} + +println("Square: \(mySquare)") // Area: 16 - ID: defaultID + +// 也可以给系统内置类型添加功能支持 +extension Int { + var customProperty: String { + return "This is \(self)" + } + + func multiplyBy(num: Int) -> Int { + return num * self + } +} + +println(7.customProperty) // "This is 7" +println(14.multiplyBy(3)) // 42 + +// 泛型: 和 Java 及 C# 的泛型类似，使用 `where` 关键字来限制类型。 +// 如果只有一个类型限制，可以省略 `where` 关键字 +func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { + for (index, value) in enumerate(array) { + if value == valueToFind { + return index + } + } + return nil +} +let foundAtIndex = findIndex([1, 2, 3, 4], 3) +println(foundAtIndex == 2) // true + +// 自定义运算符: +// 自定义运算符可以以下面的字符打头: +// / = - + * % < > ! & | ^ . ~ +// 甚至是 Unicode 的数学运算符等 +prefix operator !!! {} + +// 定义一个前缀运算符，使矩形的边长放大三倍 +prefix func !!! (inout shape: Square) -> Square { + shape.sideLength *= 3 + return shape +} + +// 当前值 +println(mySquare.sideLength) // 4 + +// 使用自定义的 !!! 运算符来把矩形边长放大三倍 +!!!mySquare +println(mySquare.sideLength) // 12 + +``` + diff --git a/zh-cn/visualbasic-cn.html.markdown b/zh-cn/visualbasic-cn.html.markdown new file mode 100644 index 00000000..95f01ed6 --- /dev/null +++ b/zh-cn/visualbasic-cn.html.markdown @@ -0,0 +1,274 @@ +--- +language: Visual Basic +contributors: + - ["Brian Martin", "http://brianmartin.biz"] +translators: + - ["Abner Chou", "http://github.com/NoahDragon"] +lang: zh-cn +filename: learnvisualbasic.vb-cn +--- + +```vb +Module Module1 + + Sub Main() + ' 让我们先从简单的终端程序学起。 + ' 单引号用来生成注释（注意是半角单引号，非全角单引号’） + ' 为了方便运行此示例代码，我写了个目录索引。 + ' 可能你还不了解以下代码的意义，但随着教程的深入， + ' 你会渐渐理解其用法。 + Console.Title = ("Learn X in Y Minutes") + Console.WriteLine("NAVIGATION") ' 显示目录 + Console.WriteLine("") + Console.ForegroundColor = ConsoleColor.Green + Console.WriteLine("1. Hello World Output") ' Hello world 输出示例 + Console.WriteLine("2. Hello World Input") ' Hello world 输入示例 + Console.WriteLine("3. Calculating Whole Numbers") ' 求整数之和 + Console.WriteLine("4. Calculating Decimal Numbers") ' 求小数之和 + Console.WriteLine("5. Working Calculator") ' 计算器 + Console.WriteLine("6. Using Do While Loops") ' 使用 Do While 循环 + Console.WriteLine("7. Using For While Loops") ' 使用 For While 循环 + Console.WriteLine("8. Conditional Statements") ' 条件语句 + Console.WriteLine("9. Select A Drink") ' 选饮料 + Console.WriteLine("50. About") ' 关于 + Console.WriteLine("Please Choose A Number From The Above List") + Dim selection As String = Console.ReadLine + Select Case selection + Case "1" ' Hello world 输出示例 + Console.Clear() ' 清空屏幕 + HelloWorldOutput() ' 调用程序块 + Case "2" ' Hello world 输入示例 + Console.Clear() + HelloWorldInput() + Case "3" ' 求整数之和 + Console.Clear() + CalculatingWholeNumbers() + Case "4" ' 求小数之和 + Console.Clear() + CalculatingDecimalNumbers() + Case "5" ' 计算器 + Console.Clear() + WorkingCalculator() + Case "6" ' 使用 do while 循环 + Console.Clear() + UsingDoWhileLoops() + Case "7" ' 使用 for while 循环 + Console.Clear() + UsingForLoops() + Case "8" ' 条件语句 + Console.Clear() + ConditionalStatement() + Case "9" ' If/Else 条件语句 + Console.Clear() + IfElseStatement() ' 选饮料 + Case "50" ' 关于本程序和作者 + Console.Clear() + Console.Title = ("Learn X in Y Minutes :: About") + MsgBox("This tutorial is by Brian Martin (@BrianMartinn") + Console.Clear() + Main() + Console.ReadLine() + + End Select + End Sub + + ' 一、对应程序目录1，下同 + + ' 使用 private subs 声明函数。 + Private Sub HelloWorldOutput() + ' 程序名 + Console.Title = "Hello World Ouput | Learn X in Y Minutes" + ' 使用 Console.Write("") 或者 Console.WriteLine("") 来输出文本到屏幕上 + ' 对应的 Console.Read() 或 Console.Readline() 用来读取键盘输入 + Console.WriteLine("Hello World") + Console.ReadLine() + ' Console.WriteLine()后加Console.ReadLine()是为了防止屏幕输出信息一闪而过 + ' 类似平时常见的“单击任意键继续”的意思。 + End Sub + + ' 二 + Private Sub HelloWorldInput() + Console.Title = "Hello World YourName | Learn X in Y Minutes" + ' 变量 + ' 用来存储用户输入的数据 + ' 变量声明以 Dim 开始，结尾为 As VariableType （变量类型）. + + ' 此教程中，我们希望知道你的姓名，并让程序记录并输出。 + Dim username As String + ' 我们定义username使用字符串类型（String）来记录用户姓名。 + Console.WriteLine("Hello, What is your name? ") ' 询问用户输入姓名 + username = Console.ReadLine() ' 存储用户名到变量 username + Console.WriteLine("Hello " + username) ' 输出将是 Hello + username + Console.ReadLine() ' 暂停屏幕并显示以上输出 + ' 以上程序将询问你的姓名，并和你打招呼。 + ' 其它变量如整型（Integer）我们用整型来处理整数。 + End Sub + + ' 三 + Private Sub CalculatingWholeNumbers() + Console.Title = "Calculating Whole Numbers | Learn X in Y Minutes" + Console.Write("First number: ") ' 输入一个整数：1，2，50，104，等等 + Dim a As Integer = Console.ReadLine() + Console.Write("Second number: ") ' 输入第二个整数 + Dim b As Integer = Console.ReadLine() + Dim c As Integer = a + b + Console.WriteLine(c) + Console.ReadLine() + ' 以上程序将两个整数相加 + End Sub + + ' 四 + Private Sub CalculatingDecimalNumbers() + Console.Title = "Calculating with Double | Learn X in Y Minutes" + ' 当然，我们还需要能够处理小数。 + ' 只需要要将整型（Integer）改为小数（Double）类型即可。 + + ' 输入一个小数： 1.2， 2.4， 50.1， 104.9，等等 + Console.Write("First number: ") + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") ' 输入第二个数 + Dim b As Double = Console.ReadLine + Dim c As Double = a + b + Console.WriteLine(c) + Console.ReadLine() + ' 以上代码能实现两个小数相加 + End Sub + + ' 五 + Private Sub WorkingCalculator() + Console.Title = "The Working Calculator| Learn X in Y Minutes" + ' 但是如果你希望有个能够处理加减乘除的计算器呢？ + ' 只需将上面代码复制粘帖即可。 + Console.Write("First number: ") ' 输入第一个数 + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") ' 输入第二个数 + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + ' 通过以下代码我们可以将以上所算的加减乘除结果输出到屏幕上。 + Console.Write(a.ToString() + " + " + b.ToString()) + ' 我们希望答案开头能有3个空格，可以使用String.PadLeft(3)方法。 + Console.WriteLine(" = " + c.ToString.PadLeft(3)) + Console.Write(a.ToString() + " * " + b.ToString()) + Console.WriteLine(" = " + d.ToString.PadLeft(3)) + Console.Write(a.ToString() + " - " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.Write(a.ToString() + " / " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.ReadLine() + + End Sub + + ' 六 + Private Sub UsingDoWhileLoops() + ' 如同以上的代码一样 + ' 这次我们将询问用户是否继续 （Yes or No?) + ' 我们将使用Do While循环，因为我们不知到用户是否需要使用一次以上。 + Console.Title = "UsingDoWhileLoops | Learn X in Y Minutes" + Dim answer As String ' 我们使用字符串变量来存储answer（答案） + Do ' 循环开始 + Console.Write("First number: ") + Dim a As Double = Console.ReadLine + Console.Write("Second number: ") + Dim b As Integer = Console.ReadLine + Dim c As Integer = a + b + Dim d As Integer = a * b + Dim e As Integer = a - b + Dim f As Integer = a / b + + Console.Write(a.ToString() + " + " + b.ToString()) + Console.WriteLine(" = " + c.ToString.PadLeft(3)) + Console.Write(a.ToString() + " * " + b.ToString()) + Console.WriteLine(" = " + d.ToString.PadLeft(3)) + Console.Write(a.ToString() + " - " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.Write(a.ToString() + " / " + b.ToString()) + Console.WriteLine(" = " + e.ToString.PadLeft(3)) + Console.ReadLine() + ' 询问用户是否继续，注意大小写。 + Console.Write("Would you like to continue? (yes / no)") + ' 程序读入用户输入 + answer = Console.ReadLine() ' added a bracket here + ' 当用户输入"yes"时，程序将跳转到Do，并再次执行 + Loop While answer = "yes" + + End Sub + + ' 七 + Private Sub UsingForLoops() + ' 有一些程序只需要运行一次。 + ' 这个程序我们将实现从10倒数计数. + + Console.Title = "Using For Loops | Learn X in Y Minutes" + ' 声明变量和Step (步长,即递减的速度，如-1，-2，-3等）。 + For i As Integer = 10 To 0 Step -1 + Console.WriteLine(i.ToString) ' 将计数结果输出的屏幕 + Next i ' 计算新的i值 + Console.WriteLine("Start") + Console.ReadLine() + End Sub + + ' 八 + Private Sub ConditionalStatement() + Console.Title = "Conditional Statements | Learn X in Y Minutes" + Dim userName As String = Console.ReadLine + Console.WriteLine("Hello, What is your name? ") ' 询问用户姓名 + userName = Console.ReadLine() ' 存储用户姓名 + If userName = "Adam" Then + Console.WriteLine("Hello Adam") + Console.WriteLine("Thanks for creating this useful site") + Console.ReadLine() + Else + Console.WriteLine("Hello " + userName) + Console.WriteLine("Have you checked out www.learnxinyminutes.com") + Console.ReadLine() ' 程序停止，并输出以上文本 + End If + End Sub + + ' 九 + Private Sub IfElseStatement() + Console.Title = "If / Else Statement | Learn X in Y Minutes" + ' 有时候我们需要考虑多于两种情况。 + ' 这时我们就需要使用If/ElesIf条件语句。 + ' If语句就好似个自动售货机，当用户输入A1，A2，A3，等去选择物品时， + ' 所有的选择可以合并到一个If语句中 + + Dim selection As String = Console.ReadLine() ' 读入用户选择 + Console.WriteLine("A1. for 7Up") ' A1 七喜 + Console.WriteLine("A2. for Fanta") ' A2 芬达 + Console.WriteLine("A3. for Dr. Pepper") ' A3 胡椒医生 + Console.WriteLine("A4. for Diet Coke") ' A4 无糖可乐 + Console.ReadLine() + If selection = "A1" Then + Console.WriteLine("7up") + Console.ReadLine() + ElseIf selection = "A2" Then + Console.WriteLine("fanta") + Console.ReadLine() + ElseIf selection = "A3" Then + Console.WriteLine("dr. pepper") + Console.ReadLine() + ElseIf selection = "A4" Then + Console.WriteLine("diet coke") + Console.ReadLine() + Else + Console.WriteLine("Please select a product") ' 请选择你需要的产品 + Console.ReadLine() + End If + + End Sub + +End Module + +``` + +## 参考 + +我（译注：原作者）在命令行下学习的VB。命令行编程使我能够更好的了解程序编译运行机制，并使学习其它语言变得容易。 + +如果希望进一步学习VB，这里还有更深层次的 <a href="http://www.vbbootcamp.co.uk/" Title="VB教学">VB教学（英文）</a>。 + +所有代码均通过测试。只需复制粘帖到Visual Basic中，并按F5运行即可。 diff --git a/zh-cn/xml-cn.html.markdown b/zh-cn/xml-cn.html.markdown new file mode 100644 index 00000000..bf0b074f --- /dev/null +++ b/zh-cn/xml-cn.html.markdown @@ -0,0 +1,127 @@ +--- +language: xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Zach Zhang", "https://github.com/checkcheckzz"] +filename: learnxml-cn.xml +lang: zh-cn +--- + +XML是一种标记语言，被设计用来存储数据和传输数据。 + +不像HTML, XML不指定怎样显示或格式化数据，只是携带它。 + + +* XML 语法 + +```xml +<!-- XML中的注解像这样 --> + +<?xml version="1.0" encoding="UTF-8"?> +<bookstore> + <book category="COOKING"> + <title lang="en">Everyday Italian</title> + <author>Giada De Laurentiis</author> + <year>2005</year> + <price>30.00</price> + </book> + <book category="CHILDREN"> + <title lang="en">Harry Potter</title> + <author>J K. Rowling</author> + <year>2005</year> + <price>29.99</price> + </book> + <book category="WEB"> + <title lang="en">Learning XML</title> + <author>Erik T. Ray</author> + <year>2003</year> + <price>39.95</price> + </book> +</bookstore> + +<!-- 上面是一个典型的XML文件。 + 它以一个声明开始，通知一些元数据（自选的） + + XML使用一个树的结构。上面的文件中，根节点是'bookstore'，它有三个孩子节点， + 所有的'books'。那些节点有更多的孩子节点，等等。。。 + + 节点用开放/关闭标签创建， 并且孩子就是在开发和关闭标签之间的节点。--> + + + +<!-- XML 携带两类信息: + 1 - 属性 -> 那是关于一个元素的元数据。 + 通常，XML解析器使用这些信息去正确地存储数据。 + 它通过在开放标签里出现在插入语中来表示。 + 2 - 元素 -> 那是纯数据。 + 那就是解析器将从XML文件提取的东西。 + 元素出现在开放和关闭标签之间，没插入语。--> + + +<!-- 下面, 一个有两个属性的元素--> +<file type="gif" id="4293">computer.gif</file> + + +``` + +* 良好格式的文件 x 验证 + +一个XML文件是良好格式的如果它是语法正确的。 +但是， 使用文件定义，比如DTD和XML概要，在文件中插入更多的限制是可能的。 + +一个遵守一个文件定义的XML文件被叫做有效的，对于那个文件来说。 + +有了这个工具，你能够在应用逻辑之外检查XML数据。 + +```xml + +<!-- 下面, 你能够看到一个简化版本的增加了DTD定义的bookstore文件。--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Bookstore.dtd"> +<bookstore> + <book category="COOKING"> + <title >Everyday Italian</title> + <price>30.00</price> + </book> +</bookstore> + +<!-- 这个DTD可能是像这样的:--> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Literature"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + + +<!-- 这个DTD以一个声明开始。 + 接下来, 根节点被声明， 它需要一个或多个孩子节点'book'。 + 每个 'book' 应该准确包含一个 'title' 和 'price' 和 + 一个被叫做'category'的缺省值为"Literature"的属性。 + 这个'title' 和 'price'节点包含一个解析过的字符数据。--> + +<!-- 这个DTD可以在XML文件中本身被声明。--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Literature"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + +<bookstore> + <book category="COOKING"> + <title >Everyday Italian</title> + <price>30.00</price> + </book> +</bookstore> +```
\ No newline at end of file diff --git a/zh-cn/yaml-cn.html.markdown b/zh-cn/yaml-cn.html.markdown new file mode 100644 index 00000000..fc510eb5 --- /dev/null +++ b/zh-cn/yaml-cn.html.markdown @@ -0,0 +1,136 @@ +--- +language: yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +translators: + - ["Zach Zhang", "https://github.com/checkcheckzz"] +filename: learnyaml-cn.yaml +lang: zh-cn +--- + +YAML是一个数据序列化语言，被设计成人类直接可写可读的。 + +它是JSON的严格超集，增加了语法显著换行符和缩进，就像Python。但和Python不一样， +YAML根本不容许文字制表符。 + + +```yaml +# YAML中的注解看起来像这样。 + +################ +# 标量类型 # +################ + +# 我们的根对象 (它们在整个文件里延续) 将会是一个地图， +# 它等价于在别的语言里的一个字典，哈西表或对象。 +key: value +another_key: Another value goes here. +a_number_value: 100 +scientific_notation: 1e+12 +boolean: true +null_value: null +key with spaces: value +# 注意到字符串不需要被引用。但是，它们可以被引用。 +"Keys can be quoted too.": "Useful if you want to put a ':' in your key." + +# 多行字符串既可以写成像一个'文字块'(使用 |)， +# 或像一个'折叠块'(使用 '>')。 +literal_block: | + This entire block of text will be the value of the 'literal_block' key, + with line breaks being preserved. + + The literal continues until de-dented, and the leading indentation is + stripped. + + Any lines that are 'more-indented' keep the rest of their indentation - + these lines will be indented by 4 spaces. +folded_style: > + This entire block of text will be the value of 'folded_style', but this + time, all newlines will be replaced with a single space. + + Blank lines, like above, are converted to a newline character. + + 'More-indented' lines keep their newlines, too - + this text will appear over two lines. + +#################### +# 集合类型 # +#################### + +# 嵌套是通过缩进完成的。 +a_nested_map: + key: value + another_key: Another Value + another_nested_map: + hello: hello + +# 地图不用有字符串键值。 +0.25: a float key + +# 键值也可以是多行对象，用?表明键值的开始。 +? | + This is a key + that has multiple lines +: and this is its value + +# YAML也容许键值是集合类型，但是很多语言将会抱怨。 + +# 序列 (等价于表或数组) 看起来像这样： +a_sequence: + - Item 1 + - Item 2 + - 0.5 # 序列可以包含不同类型。 + - Item 4 + - key: value + another_key: another_value + - + - This is a sequence + - inside another sequence + +# 因为YAML是JSON的超集，你也可以写JSON风格的地图和序列： +json_map: {"key": "value"} +json_seq: [3, 2, 1, "takeoff"] + +####################### +# 其余的YAML特点 # +####################### + +# YAML还有一个方便的特点叫'锚'，它让你简单地在整个文件里重复内容。 +# 两个键值将会有相同的值： +anchored_content: &anchor_name This string will appear as the value of two keys. +other_anchor: *anchor_name + +# YAML还有标签，你可以用它显示地声明类型。 +explicit_string: !!str 0.5 +# 一些解析器实现特定语言的标签，就像这个为了Python的复数类型。 +python_complex_number: !!python/complex 1+2j + +#################### +# 其余的YAML类型 # +#################### + +# 字符串和数字不是仅有的YAML可以理解的标量。 +# ISO 格式的日期和日期时间文字也是可以被解析的。 +datetime: 2001-12-15T02:59:43.1Z +datetime_with_spaces: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 + +# 这个!!binary标签表明一个字符串实际上是一个二进制blob的base64编码表示。 +gif_file: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML还有一个集合类型，它看起来像这样： +set: + ? item1 + ? item2 + ? item3 + +# 像Python一样，集合仅是有null数值的地图；上面的集合等价于： +set2: + item1: null + item2: null + item3: null +``` |