learnxinyminutes-docs/ru-ru/javascript-ru.html.markdown

515 lines
26 KiB
JavaScript
Raw Normal View History

2014-10-30 18:04:56 +03:00
---
language: javascript
contributors:
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
filename: javascript-ru.js
2014-12-24 16:15:34 +03:00
translators:
- ["Alexey Gonchar", "http://github.com/finico"]
- ["Andre Polykanine", "https://github.com/Oire"]
2014-10-30 18:04:56 +03:00
lang: ru-ru
---
JavaScript был создан в 1995 году Бренданом Айком, работавшим в компании Netscape.
2014-12-24 16:15:34 +03:00
Изначально он был задуман как простой язык сценариев для веб-сайтов, дополняющий
Java для более сложных веб-приложений, но его тесная интеграция с веб-страницами
и встроенная поддержка браузерами привели к тому, что он стал более распространённым,
2014-12-24 16:15:34 +03:00
чем Java в веб-интерфейсах.
2014-10-30 18:04:56 +03:00
JavaScript не ограничивается только веб-браузером: например, Node.js, программная
2014-12-24 16:15:34 +03:00
платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера
Google Chrome, становится все более популярной.
2014-10-30 18:04:56 +03:00
```js
2014-12-24 16:15:34 +03:00
// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш,
/* а многострочные комментарии начинаются с последовательности слэш-звёздочка
и заканчиваются символами звёздочка-слэш */
2014-10-30 18:04:56 +03:00
// Инструкции могут заканчиваться точкой с запятой ;
2014-10-30 18:04:56 +03:00
doStuff();
// ... но она необязательна, так как точки с запятой автоматически вставляются
2014-12-24 16:15:34 +03:00
// везде, где есть символ новой строки, за некоторыми исключениями.
2014-10-30 18:04:56 +03:00
doStuff()
2014-12-24 16:15:34 +03:00
// Так как эти исключения могут привести к неожиданным результатам, мы будем всегда
// использовать точку с запятой в этом руководстве.
2014-10-30 18:04:56 +03:00
///////////////////////////////////
2014-10-30 21:44:21 +03:00
// 1. Числа, Строки и Операторы
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// В JavaScript только один тип числа (64-bit IEEE 754 double).
// Он имеет 52-битную мантиссу, которой достаточно для хранения целых чисел
// с точностью вплоть до 9✕10¹⁵.
2014-10-30 18:04:56 +03:00
3; // = 3
1.5; // = 1.5
2014-12-24 16:15:34 +03:00
// Некоторые простые арифметические операции работают так, как вы ожидаете.
2014-10-30 18:04:56 +03:00
1 + 1; // = 2
2014-12-24 16:15:34 +03:00
0.1 + 0.2; // = 0.30000000000000004 (а некоторые - нет)
2014-10-30 18:04:56 +03:00
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
2014-12-24 16:15:34 +03:00
// Включая деление с остатком.
2014-10-30 18:04:56 +03:00
5 / 2; // = 2.5
// Побитовые операции также имеются; когда вы проводите такую операцию,
// ваше число с плавающей запятой переводится в целое со знаком
// длиной *до* 32 разрядов.
2014-10-30 18:04:56 +03:00
1 << 2; // = 4
// Приоритет в выражениях можно явно задать скобками.
2014-10-30 18:04:56 +03:00
(1 + 3) * 2; // = 8
2014-12-24 16:15:34 +03:00
// Есть три специальных значения, которые не являются реальными числами:
Infinity; // "бесконечность", например, результат деления на 0
-Infinity; // "минус бесконечность", результат деления отрицательного числа на 0
NaN; // "не число", например, результат деления 0/0
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Существует также логический тип.
2014-10-30 18:04:56 +03:00
true;
false;
2014-12-24 16:15:34 +03:00
// Строки создаются при помощи двойных или одинарных кавычек.
'абв';
"Привет, мир!";
2014-10-30 18:04:56 +03:00
// Для логического отрицания используется восклицательный знак.
2014-10-30 18:04:56 +03:00
!true; // = false
!false; // = true
2014-12-24 16:15:34 +03:00
// Строгое равенство ===
2014-10-30 18:04:56 +03:00
1 === 1; // = true
2 === 1; // = false
2014-12-24 16:15:34 +03:00
// Строгое неравенство !==
2014-10-30 18:04:56 +03:00
1 !== 1; // = false
2 !== 1; // = true
2014-12-24 16:15:34 +03:00
// Другие операторы сравнения
2014-10-30 18:04:56 +03:00
1 < 10; // = true
1 > 10; // = false
2 <= 2; // = true
2 >= 2; // = true
// Строки объединяются при помощи оператора +
"привет, " + "мир!"; // = "Привет, мир!"
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// и сравниваются при помощи < и >
2014-10-30 18:04:56 +03:00
"a" < "b"; // = true
2014-12-24 16:15:34 +03:00
// Проверка равенства с приведением типов осуществляется двойным символом равно
2014-10-30 18:04:56 +03:00
"5" == 5; // = true
null == undefined; // = true
// ...если только не использовать ===
2014-10-30 18:04:56 +03:00
"5" === 5; // = false
null === undefined; // = false
2014-12-24 16:15:34 +03:00
// ...приведение типов может привести к странному поведению...
13 + !0; // 14
"13" + !0; // '13true'
// Вы можете получить доступ к любому символу строки, используя метод charAt
"Это строка".charAt(0); // = 'Э'
2014-10-30 18:04:56 +03:00
// ...или используйте метод substring, чтобы получить более крупные части
"Привет, мир".substring(0, 6); // = "Привет"
2014-10-30 18:04:56 +03:00
// length - это свойство, для его получения не нужно использовать ()
"Привет".length; // = 6
2014-10-30 18:04:56 +03:00
// Также есть null и undefined
null; // Намеренное отсутствие значения
2014-12-24 16:15:34 +03:00
undefined; // используется для обозначения переменных, не имеющих
// присвоенного значения (хотя непосредственно undefined
// является значением)
2014-10-30 18:04:56 +03:00
// false, null, undefined, NaN, 0 и "" — это ложь; всё остальное - истина.
// Следует отметить, что 0 — это ложь, а "0" — истина, несмотря на то, что
// 0 == "0".
2014-10-30 18:04:56 +03:00
///////////////////////////////////
2014-12-24 16:15:34 +03:00
// 2. Переменные, Массивы и Объекты
2014-10-30 18:04:56 +03:00
// Переменные объявляются при помощи ключевого слова var. JavaScript — язык с
2014-12-24 16:15:34 +03:00
// динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания
// значения переменной используется символ =
2014-10-30 18:04:56 +03:00
var someVar = 5;
// если вы пропустите слово var, вы не получите сообщение об ошибке, ...
2014-10-30 18:04:56 +03:00
someOtherVar = 10;
// ...но ваша переменная будет создана в глобальном контексте, а не в текущем,
// где вы ее объявили.
2014-10-30 18:04:56 +03:00
// Переменным, объявленным без присвоения, устанавливается значение undefined.
2014-10-30 18:04:56 +03:00
var someThirdVar; // = undefined
2014-12-24 16:15:34 +03:00
// У математических операций есть сокращённые формы:
someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10
someVar *= 10; // теперь someVar имеет значение 100
2014-10-30 18:04:56 +03:00
// Ещё более краткая запись увеличения и уменьшения на единицу:
2014-12-24 16:15:34 +03:00
someVar++; // теперь someVar имеет значение 101
someVar--; // вернулись к 100
2014-10-30 18:04:56 +03:00
// Массивы — это нумерованные списки, содержащие значения любого типа.
var myArray = ["Привет", 45, true];
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками.
// Индексы массивов начинаются с нуля.
2014-10-30 18:04:56 +03:00
myArray[1]; // = 45
// Массивы можно изменять, как и их длину,
myArray.push("Мир");
2014-10-30 18:04:56 +03:00
myArray.length; // = 4
// добавлять и редактировать определённый элемент
myArray[3] = "Привет";
2014-10-30 18:04:56 +03:00
// Объекты в JavaScript похожи на словари или ассоциативные массивы в других
2014-12-24 16:15:34 +03:00
// языках: неупорядоченный набор пар ключ-значение.
var myObj = {key1: "Привет", key2: "Мир"};
2014-10-30 18:04:56 +03:00
// Ключи — это строки, но кавычки необязательны, если строка удовлетворяет
2014-12-24 16:15:34 +03:00
// ограничениям для имён переменных. Значения могут быть любых типов.
2014-10-30 18:04:56 +03:00
var myObj = {myKey: "myValue", "my other key": 4};
// Атрибуты объектов можно также получить, используя квадратные скобки
2014-10-30 18:04:56 +03:00
myObj["my other key"]; // = 4
2014-12-24 16:15:34 +03:00
// или через точку, при условии, что ключ является допустимым идентификатором.
2014-10-30 18:04:56 +03:00
myObj.myKey; // = "myValue"
2014-12-24 16:15:34 +03:00
// Объекты изменяемы; можно изменять значения и добавлять новые ключи.
2014-10-30 18:04:56 +03:00
myObj.myThirdKey = true;
// Если вы попытаетесь получить доступ к несуществующему значению,
2014-12-24 16:15:34 +03:00
// вы получите undefined.
2014-10-30 18:04:56 +03:00
myObj.myFourthKey; // = undefined
///////////////////////////////////
2014-12-24 16:15:34 +03:00
// 3. Логика и управляющие конструкции.
2014-10-30 18:04:56 +03:00
// Синтаксис для этого раздела почти такой же, как в Java.
2014-10-30 18:04:56 +03:00
// Условная конструкция работает, как и следовало ожидать,
2014-10-30 18:04:56 +03:00
var count = 1;
2014-12-24 16:15:34 +03:00
if (count == 3) {
// выполняется, если count равен 3
} else if (count == 4) {
// выполняется, если count равен 4
2014-10-30 18:04:56 +03:00
} else {
2014-12-24 16:15:34 +03:00
// выполняется, если не 3 и не 4
2014-10-30 18:04:56 +03:00
}
// ...как и цикл while.
2014-10-30 18:04:56 +03:00
while (true){
2014-12-24 16:15:34 +03:00
// Бесконечный цикл!
2014-10-30 18:04:56 +03:00
}
// Цикл do-while такой же, как while, но он всегда выполняется хотя бы раз.
2014-10-30 18:04:56 +03:00
var input
do {
input = getInput();
} while (!isValid(input))
// цикл for такой же, как в C и Java:
2014-12-24 16:15:34 +03:00
// инициализация; условие; шаг.
for (var i = 0; i < 5; i++) {
// выполнится 5 раз
2014-10-30 18:04:56 +03:00
}
// && — это логическое И, || — это логическое ИЛИ
if (house.size == "big" && house.color == "blue") {
2014-10-30 18:04:56 +03:00
house.contains = "bear";
}
if (color == "red" || color == "blue") {
2014-12-24 16:15:34 +03:00
// цвет красный или синий
2014-10-30 18:04:56 +03:00
}
// && и || используют сокращённое вычисление, что полезно
// для задания значений по умолчанию.
2014-10-30 18:04:56 +03:00
var name = otherName || "default";
// Оператор switch выполняет проверку на равенство при помощи ===
// используйте break, чтобы прервать выполнение после каждого case,
// или выполнение пойдёт далее даже после правильного варианта.
grade = 4;
2014-10-30 18:04:56 +03:00
switch (grade) {
case 5:
console.log("Отлично");
2014-10-30 18:04:56 +03:00
break;
case 4:
console.log("Хорошо");
2014-10-30 18:04:56 +03:00
break;
case 3:
console.log("Можете и лучше");
2014-10-30 18:04:56 +03:00
break;
default:
console.log("Ой-вей!");
2014-10-30 18:04:56 +03:00
break;
}
///////////////////////////////////
// 4. Функции, Область видимости и Замыкания
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Функции в JavaScript объявляются при помощи ключевого слова function.
function myFunction(thing) {
return thing.toUpperCase();
2014-10-30 18:04:56 +03:00
}
myFunction("foo"); // = "FOO"
2014-12-24 16:15:34 +03:00
// Обратите внимание, что значение, которое будет возвращено, должно начинаться
// на той же строке, что и ключевое слово return, в противном случае вы будете
// всегда возвращать undefined по причине автоматической вставки точки с запятой.
// Следите за этим при использовании стиля форматирования Allman.
2014-10-30 18:04:56 +03:00
function myFunction()
{
2014-12-24 16:15:34 +03:00
return // <- здесь точка с запятой вставится автоматически
2014-10-30 18:04:56 +03:00
{
thisIsAn: 'object literal'
}
}
myFunction(); // = undefined
// В JavaScript функции — это объекты первого класса, поэтому они могут быть
// присвоены различным именам переменных и передаваться другим функциям
// в качестве аргументов, например, когда назначается обработчик события:
2014-12-24 16:15:34 +03:00
function myFunction() {
// этот код будет вызван через 5 секунд
2014-10-30 18:04:56 +03:00
}
setTimeout(myFunction, 5000);
2014-12-24 16:15:34 +03:00
// Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js
2014-10-30 18:04:56 +03:00
// Функции не обязательно должны иметь имя при объявлении — вы можете написать
// анонимное определение функции непосредственно в аргументе другой функции.
2014-12-24 16:15:34 +03:00
setTimeout(function() {
// этот код будет вызван через 5 секунд
2014-10-30 18:04:56 +03:00
}, 5000);
// В JavaScript есть область видимости; функции имеют свою область
// видимости, а другие блоки — нет.
2014-12-24 16:15:34 +03:00
if (true) {
2014-10-30 18:04:56 +03:00
var i = 5;
}
i; // = 5, а не undefined, как ожидалось бы в языках с блочной областью видимости
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Это привело к общепринятому шаблону "самозапускающихся анонимных функций",
// которые препятствуют проникновению переменных в глобальную область видимости
(function() {
2014-10-30 18:04:56 +03:00
var temporary = 5;
// Мы можем получить доступ к глобальной области для записи в «глобальный объект»,
2014-12-24 16:15:34 +03:00
// который в веб-браузере всегда window. Глобальный объект может иметь другое
// имя в таких платформах, как Node.js
2014-10-30 18:04:56 +03:00
window.permanent = 10;
})();
2014-12-24 16:15:34 +03:00
temporary; // вызовет сообщение об ошибке с типом ReferenceError
2014-10-30 18:04:56 +03:00
permanent; // = 10
2014-12-24 16:15:34 +03:00
// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
// определена внутри другой функции, то внутренняя функция имеет доступ к
// переменным внешней функции даже после того, как контекст выполнения выйдет из
2014-12-24 16:15:34 +03:00
// внешней функции.
function sayHelloInFiveSeconds(name) {
var prompt = "Привет, " + name + "!";
2014-12-24 16:15:34 +03:00
// Внутренние функции по умолчанию помещаются в локальную область видимости,
// как если бы они были объявлены с помощью var.
2014-12-24 16:15:34 +03:00
function inner() {
2014-10-30 18:04:56 +03:00
alert(prompt);
}
setTimeout(inner, 5000);
// setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет,
// после чего setTimeout вызовет функцию inner. Однако поскольку функция inner
// «замкнута» вокруг sayHelloInFiveSeconds, она по-прежнему имеет доступ к переменной prompt
// на то время, когда она наконец будет вызвана.
2014-10-30 18:04:56 +03:00
}
sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!»
2014-10-30 18:04:56 +03:00
///////////////////////////////////
// 5. Подробнее об объектах; Конструкторы и Прототипы
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Объекты могут содержать в себе функции.
2014-10-30 18:04:56 +03:00
var myObj = {
2014-12-24 16:15:34 +03:00
myFunc: function() {
return "Привет, мир!";
2014-10-30 18:04:56 +03:00
}
};
myObj.myFunc(); // = "Привет, мир!"
2014-10-30 18:04:56 +03:00
// Когда вызываются функции, прикреплённые к объекту, они могут получить доступ
2014-12-24 16:15:34 +03:00
// к этому объекту с помощью ключевого слова this.
2014-10-30 18:04:56 +03:00
myObj = {
myString: "Привет, мир!",
2014-12-24 16:15:34 +03:00
myFunc: function() {
2014-10-30 18:04:56 +03:00
return this.myString;
}
};
myObj.myFunc(); // = "Привет, мир!"
2014-10-30 18:04:56 +03:00
// Значение this зависит от того, как функция вызывается,
// а не от того, где она определена. Таким образом, наша функция не работает,
// если она вызывается не в контексте объекта.
2014-10-30 18:04:56 +03:00
var myFunc = myObj.myFunc;
myFunc(); // = undefined
2014-12-24 16:15:34 +03:00
// И наоборот, функция может быть присвоена объекту и получать доступ к нему
// через this, даже если она не была прикреплена к нему при объявлении.
2014-12-24 16:15:34 +03:00
var myOtherFunc = function() {
return this.myString.toUpperCase();
2014-10-30 18:04:56 +03:00
}
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!"
2014-10-30 18:04:56 +03:00
// Мы можем также указать контекст для выполнения функции при её вызове,
// используя call или apply.
2014-12-24 16:15:34 +03:00
var anotherFunc = function(s) {
2014-10-30 18:04:56 +03:00
return this.myString + s;
}
anotherFunc.call(myObj, " И привет, Луна!"); // = "Привет, мир! И привет, Луна!"
2014-10-30 18:04:56 +03:00
// Функция apply почти такая же, но принимает в качестве списка аргументов массив.
anotherFunc.apply(myObj, [" И привет, Солнце!"]); // = "Привет, мир! И привет, Солнце!"
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Это полезно при работе с функцией, которая принимает последовательность
// аргументов, а вы хотите передать массив.
2014-10-30 18:04:56 +03:00
Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (Ой-ой!)
2014-10-30 18:04:56 +03:00
Math.min.apply(Math, [42, 6, 27]); // = 6
// Но call и apply — только временные. Когда мы хотим связать функцию с объектом,
// мы можем использовать bind.
2014-10-30 18:04:56 +03:00
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" И привет, Сатурн!"); // = "Привет, мир! И привет, Сатурн!"
2014-10-30 18:04:56 +03:00
// Bind также может использоваться для частичного применения (каррирования) функции
2014-12-24 16:15:34 +03:00
var product = function(a, b) { return a * b; }
2014-10-30 18:04:56 +03:00
var doubler = product.bind(this, 2);
doubler(8); // = 16
// Когда вы вызываете функцию с помощью ключевого слова new, создается новый объект,
// доступный функции при помощи this. Такие функции называют конструкторами.
2014-12-24 16:15:34 +03:00
var MyConstructor = function() {
2014-10-30 18:04:56 +03:00
this.myNumber = 5;
}
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
// У каждого объекта в JavaScript есть прототип. Когда вы хотите получить
// доступ к свойству объекта, которое не существует в этом объекте, интерпретатор
2014-12-24 16:15:34 +03:00
// будет искать это свойство в прототипе.
2014-10-30 18:04:56 +03:00
// Некоторые реализации языка позволяют получить доступ к прототипу объекта
// через «магическое» свойство __proto__. Несмотря на то, что это может быть полезно
// для понимания прототипов, это не часть стандарта; мы увидим стандартные способы
2014-12-24 16:15:34 +03:00
// использования прототипов позже.
2014-10-30 18:04:56 +03:00
var myObj = {
myString: "Привет, мир!"
2014-10-30 18:04:56 +03:00
};
var myPrototype = {
meaningOfLife: 42,
2014-12-24 16:15:34 +03:00
myFunc: function() {
2014-10-30 18:04:56 +03:00
return this.myString.toLowerCase()
}
};
myObj.__proto__ = myPrototype;
myObj.meaningOfLife; // = 42
2014-12-24 16:15:34 +03:00
// Для функций это тоже работает.
myObj.myFunc(); // = "Привет, мир!"
2014-10-30 18:04:56 +03:00
// Если интерпретатор не найдёт свойство в прототипе, то продожит поиск
// в прототипе прототипа и так далее.
2014-10-30 18:04:56 +03:00
myPrototype.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
2014-12-24 16:15:34 +03:00
// Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип.
// Это означает, что мы можем изменить прототип, и наши изменения будут отражены везде.
2014-10-30 18:04:56 +03:00
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
// Мы упомянули, что свойство __proto__ нестандартно, и нет никакого стандартного
// способа, чтобы изменить прототип существующего объекта. Однако есть два
2014-12-24 16:15:34 +03:00
// способа создать новый объект с заданным прототипом.
2014-10-30 18:04:56 +03:00
// Первый способ — это Object.create, который появился в JavaScript недавно,
// а потому доступен ещё не во всех реализациях языка.
2014-10-30 18:04:56 +03:00
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
2014-12-24 16:15:34 +03:00
// Второй способ, который работает везде, имеет дело с конструкторами.
// У конструкторов есть свойство с именем prototype. Это *не* прототип
2014-12-24 16:15:34 +03:00
// функции-конструктора; напротив, это прототип для новых объектов, которые
// будут созданы с помощью этого конструктора и ключевого слова new.
2014-10-30 18:04:56 +03:00
MyConstructor.prototype = {
myNumber: 5,
2014-12-24 16:15:34 +03:00
getMyNumber: function() {
2014-10-30 18:04:56 +03:00
return this.myNumber;
}
};
var myNewObj2 = new MyConstructor();
myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6
myNewObj2.getMyNumber(); // = 6
// У встроенных типов, таких, как строки и числа, также есть конструкторы, которые
// создают эквивалентные объекты-обёртки.
2014-10-30 18:04:56 +03:00
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
2014-12-24 16:15:34 +03:00
// За исключением того, что они не в точности равны.
2014-10-30 18:04:56 +03:00
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
2014-12-24 16:15:34 +03:00
if (0) {
// Этот код не выполнится, потому что 0 - это ложь.
2014-10-30 18:04:56 +03:00
}
// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
// поэтому вы можете расширить функционал строк, например:
2014-12-24 16:15:34 +03:00
String.prototype.firstCharacter = function() {
2014-10-30 18:04:56 +03:00
return this.charAt(0);
}
"abc".firstCharacter(); // = "a"
// Это часто используется в т.н. полифилах, которые реализуют новые возможности
2014-12-24 16:15:34 +03:00
// JavaScript в старой реализации языка, так что они могут быть использованы в
// старых средах, таких, как устаревшие браузеры.
2014-10-30 18:04:56 +03:00
2014-12-24 16:15:34 +03:00
// Например, мы упомянули, что Object.create доступен не во всех реализациях, но
// мы сможем использовать его с помощью такого полифила:
if (Object.create === undefined) { // не перезаписываем метод, если он существует
2014-12-24 16:15:34 +03:00
Object.create = function(proto) {
// создаём временный конструктор с правильным прототипом
2014-10-30 18:04:56 +03:00
var Constructor = function(){};
Constructor.prototype = proto;
// затем используем его для создания нового,
// правильно прототипированного объекта
2014-10-30 18:04:56 +03:00
return new Constructor();
}
}
```
## Что ещё почитать
2014-10-30 18:04:56 +03:00
[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) —
2014-12-24 16:15:34 +03:00
качественный учебник по JavaScript на русском языке.
2014-10-30 18:04:56 +03:00
[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) —
2014-12-24 16:15:34 +03:00
предоставляет отличную документацию для JavaScript, как он используется в браузерах.
Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим,
делясь своими знаниями.
2014-10-30 18:04:56 +03:00
[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — это
подробное руководство по всем неинтуитивным особенностей языка.
2014-10-30 18:04:56 +03:00
[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) — можно
2014-12-24 16:15:34 +03:00
найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому.