mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 10:01:38 +00:00
597 lines
23 KiB
Markdown
597 lines
23 KiB
Markdown
---
|
||
language: javascript
|
||
contributors:
|
||
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
|
||
- ["Ariel Krakowski", "http://www.learneroo.com"]
|
||
translators:
|
||
- ["--mynamehere--", "http://github.com/--mynamehere--"]
|
||
filename: javascript-ru.js
|
||
lang: ru-ru
|
||
---
|
||
|
||
todo: привести все названия языка к коректному написанию
|
||
|
||
Javascript был разработан Бренданом Айком из Netcape в 1995. Изначально
|
||
предполагалось, что он станет простым вариантом скриптового языка для сайтов,
|
||
дополняющий к Java, который в свою очередь использовался бы для более сложных
|
||
web-приложений. Но тонкая интегрированность javascript с web-страницей и
|
||
встроенная поддержка в браузерах привели к тому, чтобы он стал более
|
||
распространен в web-разработке, чем Java.
|
||
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.
|
||
|
||
Использование Javascript не ограничивается браузерами. Проект Node.js,
|
||
предоставляющий независимую среду выполнения на движке Google Chrome V8
|
||
JavaScript, становится все более популярным.
|
||
JavaScript isn't just limited to web browsers, though: Node.js, a project that
|
||
provides a standalone runtime for Google Chrome's V8 JavaScript engine, is
|
||
becoming more and more popular.
|
||
|
||
Обратная связь важна и нужна! Вы можете написаться мне
|
||
на [@_remedy]() или
|
||
[mymail]().
|
||
Feedback would be highly appreciated! You can reach me at
|
||
[@adambrenecki](https://twitter.com/adambrenecki), or
|
||
[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
|
||
|
||
```js
|
||
// Комментарии оформляются как в C.
|
||
// Обнострочнные комментарии начинаются с двух слешей,
|
||
// Comments are like C. Single-line comments start with two slashes,
|
||
/* а многострочные с слеша и звездочки
|
||
и заканчиваются звездочеий и слешом */
|
||
/* and multiline comments start with slash-star
|
||
and end with star-slash */
|
||
|
||
// Выражения разделяются с помощью ;
|
||
// Statements can be terminated by ;
|
||
doStuff();
|
||
|
||
// ... но этого можно и делать, разделители подставляются автоматически
|
||
// после перехода на новую строку за исключением особых случаев
|
||
// ... but they don't have to be, as semicolons are automatically inserted
|
||
// wherever there's a newline, except in certain cases.
|
||
doStuff()
|
||
|
||
// Это может приводить к непредсказуемому результату и поэтому мы будем
|
||
// использовать разделители в этом туре.
|
||
// Because those cases can cause unexpected results, we'll keep on using
|
||
// semicolons in this guide.
|
||
|
||
///////////////////////////////////
|
||
// 1. Числа, Строки и Операторы
|
||
// 1. Numbers, Strings and Operators
|
||
|
||
// В Javasript всего 1 числовой тип - 64-битное число с плавающей точкой стандарта
|
||
// IEEE 754)
|
||
// todo: сформулировать
|
||
// 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
|
||
|
||
// В основном базовая арифметика работает предсказуемо
|
||
// Some basic arithmetic works as you'd expect.
|
||
1 + 1; // = 2
|
||
.1 + .2; // = 0.30000000000000004
|
||
8 - 1; // = 7
|
||
10 * 2; // = 20
|
||
35 / 5; // = 7
|
||
|
||
// Включая нецелочисленное деление (todo:уточнить!)
|
||
// Including uneven division.
|
||
5 / 2; // = 2.5
|
||
|
||
// Двоичные операции тоже есть. Если применить двоичную операцию к float-числу,
|
||
// оно будет приведено к 32-битному целому со знаком.
|
||
// 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
|
||
|
||
// (todo:перевести)
|
||
// Precedence is enforced with parentheses.
|
||
(1 + 3) * 2; // = 8
|
||
|
||
// Есть три особых не реальных числовых значения:
|
||
// There are three special not-a-real-number values:
|
||
Infinity; // допустим, результат операции 1/0
|
||
-Infinity; // допустим, результат операции -1/0
|
||
NaN; // допустим, результат операции 0/0
|
||
|
||
// Так же есть тип булевых данных.
|
||
// There's also a boolean type.
|
||
true;
|
||
false;
|
||
|
||
// Строки создаются с помощью ' или ".
|
||
// Strings are created with ' or ".
|
||
'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
|
||
|
||
// Приведение типов выполняется при сравнении с ==...
|
||
// Type coercion is performed for comparisons with double equals...
|
||
"5" == 5; // = true
|
||
null == undefined; // = true
|
||
|
||
// ...в отличие от ===
|
||
"5" === 5; // = false
|
||
null === undefined; // = false
|
||
|
||
// Для доступа к конкретному символу строки используйте charAt
|
||
// You can access characters in a string with charAt
|
||
"This is a string".charAt(0); // = 'T'
|
||
|
||
// ... или используйте substring для получения подстроки
|
||
// ...or use substring to get larger pieces
|
||
"Hello world".substring(0, 5); // = "Hello"
|
||
|
||
// length(длина) - свойство, не используйте ()
|
||
// length is a property, so don't use ()
|
||
"Hello".length; // = 5
|
||
|
||
// Есть null и undefined
|
||
// There's also null and undefined
|
||
null; // используется что бы указать явно, что значения нет
|
||
undefined; // испрользуется чтобы показать, что значения не было установлено
|
||
// собственно, undefined так и переводится
|
||
|
||
// false, null, undefined, NaN, 0 и "" являются falsy-значениями(при приведении
|
||
// в булеву типу становятся false)
|
||
// false, null, undefined, NaN, 0 and "" are falsy; everything else is truthy.
|
||
// Обратите внимание что 0 приводится к false, а "0" к true, не смотря на то,
|
||
// что "0"==0
|
||
// Note that 0 is falsy and "0" is truthy, even though 0 == "0".
|
||
|
||
///////////////////////////////////
|
||
// 2. Переменные, массивы и объекты
|
||
|
||
// Переменные объявляются ключевым словом var. Javascript динамически
|
||
// типизируемый, так что указывать тип не нужно.
|
||
// Присвоение значения описывается с помощью оператора =
|
||
// 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;
|
||
|
||
// если не указать ключевого слова var, ошибки не будет...
|
||
// if you leave the var keyword off, you won't get an error...
|
||
someOtherVar = 10;
|
||
|
||
// ...но переменная будет создана в глобальном контексте, в не области
|
||
// видимости, в которой она была объявлена.
|
||
// ...but your variable will be created in the global scope, not in the scope
|
||
// you defined it in.
|
||
|
||
// Переменные объявленные без присвоения значения, содержать undefined
|
||
// Variables declared without being assigned to are set to undefined.
|
||
var someThirdVar; // = undefined
|
||
|
||
// Для математических операций над числами есть короткая запись:
|
||
// There's shorthand for performing math operations on variables:
|
||
someVar += 5; // тоже что someVar = someVar + 5; someVar равно 10 теперь
|
||
someVar *= 10; // а теперь -- 100
|
||
|
||
// еще более короткая запись для добавления и вычитания 1
|
||
someVar++; // теперь someVar равно 101
|
||
someVar--; // обратно к 100
|
||
|
||
// Массивы -- упорядоченные списки значений любых типов.
|
||
// Arrays are ordered lists of values, of any type.
|
||
var myArray = ["Hello", 45, true];
|
||
|
||
// Для доступу к элементам массивов используйте квадратные скобки.
|
||
// Индексы массивов начинаются с 0
|
||
// Their members can be accessed using the square-brackets subscript syntax.
|
||
// Array indices start at zero.
|
||
myArray[1]; // = 45
|
||
|
||
// Массивы мутабельны(изменяемы) и имеют переменную длину.
|
||
// Arrays are mutable and of variable length.
|
||
myArray.push("World"); // добавить элемент
|
||
myArray.length; // = 4
|
||
|
||
// Добавить или изменить значение по конкретному индексу
|
||
myArray[3] = "Hello";
|
||
|
||
// Объёкты javascript похожи на dictionary или map из других языков
|
||
// программирования. Это неупорядочнные коллекции пар ключ-значение.
|
||
// JavaScript's objects are equivalent to 'dictionaries' or 'maps' in other
|
||
// languages: an unordered collection of key-value pairs.
|
||
var myObj = {key1: "Hello", key2: "World"};
|
||
|
||
// Ключи -- это строки, но кавычки не требуются если названия явлюятся
|
||
// корректными javascript идентификаторами. Значения могут быть любого типа.
|
||
// 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};
|
||
|
||
// Доступ к атрибту объекта можно получить с помощью квадратных скобок
|
||
// Object attributes can also be accessed using the subscript syntax,
|
||
myObj["my other key"]; // = 4
|
||
|
||
// ... или используя точечную нотацию, при условии что ключ является
|
||
// корректным идентификатором
|
||
// ... or using the dot syntax, provided the key is a valid identifier.
|
||
myObj.myKey; // = "myValue"
|
||
|
||
// Объекты мутабельны. В существуюещем объекте можно изменить значние
|
||
// или добавить новый атрибут
|
||
// Objects are mutable; values can be changed and new keys added.
|
||
myObj.myThirdKey = true;
|
||
|
||
// При попытке доступа к атрибуту, который до этого не был создан, будет
|
||
// возвращен undefined
|
||
// If you try to access a value that's not yet set, you'll get undefined.
|
||
myObj.myFourthKey; // = undefined
|
||
|
||
///////////////////////////////////
|
||
// 3. Logic and Control Structures
|
||
|
||
// 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){
|
||
// evaluated if count is 4
|
||
} else {
|
||
// evaluated if it's not either 3 or 4
|
||
}
|
||
|
||
// As does while.
|
||
while (true){
|
||
// An infinite loop!
|
||
}
|
||
|
||
// Do-while loops are like while loops, except they always run at least once.
|
||
var input
|
||
do {
|
||
input = getInput();
|
||
} while (!isValid(input))
|
||
|
||
// 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
|
||
}
|
||
|
||
// && is logical and, || is logical or
|
||
if (house.size == "big" && house.colour == "blue"){
|
||
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";
|
||
|
||
|
||
// 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.
|
||
function myFunction(thing){
|
||
return thing.toUpperCase();
|
||
}
|
||
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'
|
||
}
|
||
}
|
||
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
|
||
// example, when supplying an event handler:
|
||
function myFunction(){
|
||
// this code will be called in 5 seconds' time
|
||
}
|
||
setTimeout(myFunction, 5000);
|
||
// Note: setTimeout isn't part of the JS language, but is provided by browsers
|
||
// and Node.js.
|
||
|
||
// 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);
|
||
|
||
// JavaScript has function scope; functions get their own scope but other blocks
|
||
// do not.
|
||
if (true){
|
||
var i = 5;
|
||
}
|
||
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
|
||
// different name in non-browser environments such as Node.js.
|
||
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, even after the outer function exits.
|
||
function sayHelloInFiveSeconds(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);
|
||
}
|
||
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
|
||
|
||
///////////////////////////////////
|
||
// 5. More about Objects; Constructors and Prototypes
|
||
|
||
// Objects can contain functions.
|
||
var myObj = {
|
||
myFunc: function(){
|
||
return "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.
|
||
myObj = {
|
||
myString: "Hello world!",
|
||
myFunc: function(){
|
||
return this.myString;
|
||
}
|
||
};
|
||
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
|
||
|
||
// 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.
|
||
var myOtherFunc = function(){
|
||
return this.myString.toUpperCase();
|
||
}
|
||
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.
|
||
|
||
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;
|
||
}
|
||
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
|
||
// part of the standard; we'll get to standard ways of using prototypes later.
|
||
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!"
|
||
|
||
// 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
|
||
|
||
// 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
|
||
|
||
// 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
|
||
|
||
// 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 = {
|
||
myNumber: 5,
|
||
getMyNumber: function(){
|
||
return this.myNumber;
|
||
}
|
||
};
|
||
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
|
||
|
||
// Except, they aren't exactly equivalent.
|
||
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);
|
||
}
|
||
"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
|
||
// used in older environments such as outdated browsers.
|
||
|
||
// For instance, we mentioned that Object.create isn't yet available in all
|
||
// implementations, but we can still use it with this polyfill:
|
||
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();
|
||
}
|
||
}
|
||
```
|
||
|
||
## Further Reading
|
||
|
||
The [Mozilla Developer
|
||
Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides
|
||
excellent documentation for JavaScript as it's used in browsers. Plus, it's a
|
||
wiki, so as you learn more you can help others out by sharing your own
|
||
knowledge.
|
||
|
||
MDN's [A re-introduction to
|
||
JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
|
||
covers much of the concepts covered here in more detail. This guide has quite
|
||
deliberately only covered the JavaScript language itself; if you want to learn
|
||
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)
|
||
|
||
[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)
|
||
on the Mozilla Developer Network.
|