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

544 lines
26 KiB
Markdown
Raw Normal View History

2014-10-30 15:04:56 +00:00
---
language: javascript
contributors:
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
translators:
- ["Maxim Koretskiy", "http://github.com/maximkoretskiy"]
2014-10-30 15:04:56 +00:00
filename: javascript-ru.js
lang: ru-ru
---
2014-10-30 18:41:16 +00:00
Javascript был разработан Бренданом Айком из Netcape в 1995. Изначально
предполагалось, что он станет простым вариантом скриптового языка для сайтов,
дополняющий к Java, который бы в свою очередь использовался для более сложных
2014-10-30 18:41:16 +00:00
web-приложений. Но тонкая интегрированность javascript с web-страницей и
встроенная поддержка в браузерах привели к тому, чтобы он стал более
распространен в frontend-разработке, чем Java.
Использование JavaScript не ограничивается браузерами. Проект Node.js,
2014-10-30 18:41:16 +00:00
предоставляющий независимую среду выполнения на движке Google Chrome V8
JavaScript, становится все более популярным.
2014-10-30 15:04:56 +00:00
2014-10-30 18:41:16 +00:00
Обратная связь важна и нужна! Вы можете написаться мне
на [@adambrenecki](https://twitter.com/adambrenecki) или
2014-10-30 15:04:56 +00:00
[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
```js
2014-10-30 18:44:21 +00:00
// Комментарии оформляются как в C.
// Однострочнные коментарии начинаются с двух слешей,
2014-10-30 18:44:21 +00:00
/* а многострочные с слеша и звездочки
и заканчиваются звездочеий и слешом */
2014-10-30 15:04:56 +00:00
2014-10-30 18:44:21 +00:00
// Выражения разделяются с помощью ;
2014-10-30 15:04:56 +00:00
doStuff();
// ... но этого можно и не делать, разделители подставляются автоматически
2014-10-30 18:44:21 +00:00
// после перехода на новую строку за исключением особых случаев
2014-10-30 15:04:56 +00:00
doStuff()
2014-10-30 18:44:21 +00:00
// Это может приводить к непредсказуемому результату и поэтому мы будем
// использовать разделители в этом туре.
2014-10-30 15:04:56 +00:00
// Because those cases can cause unexpected results, we'll keep on using
// semicolons in this guide.
///////////////////////////////////
2014-10-30 18:44:21 +00:00
// 1. Числа, Строки и Операторы
2014-10-30 15:04:56 +00:00
// 1. Numbers, Strings and Operators
// В Javasript всего 1 числовой тип - 64-битное число с плавающей точкой
// стандарта IEEE 754)
// Числа имеют 52-битную мантиссу, чего достаточно для хранения хранения целых
// чисел до 9✕10¹⁵ приблизительно.
2014-10-30 15:04:56 +00:00
3; // = 3
1.5; // = 1.5
2014-10-30 18:44:21 +00:00
// В основном базовая арифметика работает предсказуемо
2014-10-30 15:04:56 +00:00
1 + 1; // = 2
.1 + .2; // = 0.30000000000000004
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
// Включая нецелочисленное деление
2014-10-30 15:04:56 +00:00
5 / 2; // = 2.5
2014-10-30 18:44:21 +00:00
// Двоичные операции тоже есть. Если применить двоичную операцию к float-числу,
// оно будет приведено к 32-битному целому со знаком.
2014-10-30 15:04:56 +00:00
1 << 2; // = 4
2014-10-30 18:44:21 +00:00
// (todo:перевести)
// Приоритет выполнения операций можно менять с помощью скобок.
2014-10-30 15:04:56 +00:00
(1 + 3) * 2; // = 8
2014-10-30 18:44:21 +00:00
// Есть три особых не реальных числовых значения:
Infinity; // допустим, результат операции 1/0
-Infinity; // допустим, результат операции -1/0
NaN; // допустим, результат операции 0/0
2014-10-30 15:04:56 +00:00
2014-10-30 18:44:21 +00:00
// Так же есть тип булевых данных.
2014-10-30 15:04:56 +00:00
true;
false;
2014-10-30 18:44:21 +00:00
// Строки создаются с помощью ' или ".
2014-10-30 15:04:56 +00:00
'abc';
"Hello, world";
2014-10-30 18:44:21 +00:00
// Оператор ! означает отрицание
2014-10-30 15:04:56 +00:00
!true; // = false
!false; // = true
2014-10-30 18:44:21 +00:00
// Равество это ===
2014-10-30 15:04:56 +00:00
1 === 1; // = true
2 === 1; // = false
2014-10-30 18:44:21 +00:00
// Неравенство это !==
2014-10-30 15:04:56 +00:00
1 !== 1; // = false
2 !== 1; // = true
2014-10-30 18:44:21 +00:00
// Еще сравнения
2014-10-30 15:04:56 +00:00
1 < 10; // = true
1 > 10; // = false
2 <= 2; // = true
2 >= 2; // = true
2014-10-30 18:44:21 +00:00
// Строки складываются с помощью +
2014-10-30 15:04:56 +00:00
"Hello " + "world!"; // = "Hello world!"
2014-10-30 18:44:21 +00:00
// и сравниваются с помощью < и >
2014-10-30 15:04:56 +00:00
"a" < "b"; // = true
2014-10-30 18:44:21 +00:00
// Приведение типов выполняется при сравнении с ==...
2014-10-30 15:04:56 +00:00
"5" == 5; // = true
null == undefined; // = true
2014-10-30 18:44:21 +00:00
// ...в отличие от ===
2014-10-30 15:04:56 +00:00
"5" === 5; // = false
null === undefined; // = false
2014-10-30 18:44:21 +00:00
// Для доступа к конкретному символу строки используйте charAt
2014-10-30 15:04:56 +00:00
"This is a string".charAt(0); // = 'T'
2014-10-30 18:44:21 +00:00
// ... или используйте substring для получения подстроки
2014-10-30 15:04:56 +00:00
"Hello world".substring(0, 5); // = "Hello"
2014-10-30 18:44:21 +00:00
// length(длина) - свойство, не используйте ()
2014-10-30 15:04:56 +00:00
"Hello".length; // = 5
2014-10-30 18:44:21 +00:00
// Есть null и undefined
null; // используется что бы указать явно, что значения нет
undefined; // испрользуется чтобы показать, что значения не было установлено
// собственно, undefined так и переводится
2014-10-30 15:04:56 +00:00
2014-10-30 18:44:21 +00:00
// false, null, undefined, NaN, 0 и "" являются falsy-значениями(при приведении
// в булеву типу становятся false)
// Обратите внимание что 0 приводится к false, а "0" к true,
// не смотря на то, что "0"==0
2014-10-30 15:04:56 +00:00
///////////////////////////////////
2014-10-30 18:58:59 +00:00
// 2. Переменные, массивы и объекты
2014-10-30 15:04:56 +00:00
2014-10-30 18:58:59 +00:00
// Переменные объявляются ключевым словом var. Javascript динамически
// типизируемый, так что указывать тип не нужно.
// Присвоение значения описывается с помощью оператора =
2014-10-30 15:04:56 +00:00
var someVar = 5;
2014-10-30 18:58:59 +00:00
// если не указать ключевого слова var, ошибки не будет...
2014-10-30 15:04:56 +00:00
someOtherVar = 10;
2014-10-30 18:58:59 +00:00
// ...но переменная будет создана в глобальном контексте, в не области
// видимости, в которой она была объявлена.
2014-10-30 15:04:56 +00:00
2014-10-30 18:58:59 +00:00
// Переменные объявленные без присвоения значения, содержать undefined
2014-10-30 15:04:56 +00:00
var someThirdVar; // = undefined
// Для математических операций над переменными есть короткая запись:
2014-10-30 18:58:59 +00:00
someVar += 5; // тоже что someVar = someVar + 5; someVar равно 10 теперь
someVar *= 10; // а теперь -- 100
2014-10-30 15:04:56 +00:00
2014-10-30 18:58:59 +00:00
// еще более короткая запись для добавления и вычитания 1
someVar++; // теперь someVar равно 101
someVar--; // обратно к 100
2014-10-30 15:04:56 +00:00
2014-10-30 18:58:59 +00:00
// Массивы -- упорядоченные списки значений любых типов.
2014-10-30 15:04:56 +00:00
var myArray = ["Hello", 45, true];
2014-10-30 18:58:59 +00:00
// Для доступу к элементам массивов используйте квадратные скобки.
// Индексы массивов начинаются с 0
2014-10-30 15:04:56 +00:00
myArray[1]; // = 45
2014-10-30 18:58:59 +00:00
// Массивы мутабельны(изменяемы) и имеют переменную длину.
myArray.push("World"); // добавить элемент
2014-10-30 15:04:56 +00:00
myArray.length; // = 4
2014-10-30 18:58:59 +00:00
// Добавить или изменить значение по конкретному индексу
2014-10-30 15:04:56 +00:00
myArray[3] = "Hello";
// Объекты javascript похожи на dictionary или map из других языков
2014-10-30 18:58:59 +00:00
// программирования. Это неупорядочнные коллекции пар ключ-значение.
2014-10-30 15:04:56 +00:00
var myObj = {key1: "Hello", key2: "World"};
2014-10-30 18:58:59 +00:00
// Ключи -- это строки, но кавычки не требуются если названия явлюятся
// корректными javascript идентификаторами. Значения могут быть любого типа.
2014-10-30 15:04:56 +00:00
var myObj = {myKey: "myValue", "my other key": 4};
2014-10-30 18:58:59 +00:00
// Доступ к атрибту объекта можно получить с помощью квадратных скобок
2014-10-30 15:04:56 +00:00
myObj["my other key"]; // = 4
2014-10-30 18:58:59 +00:00
// ... или используя точечную нотацию, при условии что ключ является
2014-11-01 19:55:18 +00:00
// корректным идентификатором.
2014-10-30 15:04:56 +00:00
myObj.myKey; // = "myValue"
2014-10-30 18:58:59 +00:00
// Объекты мутабельны. В существуюещем объекте можно изменить значние
2014-11-01 19:55:18 +00:00
// или добавить новый атрибут.
2014-10-30 15:04:56 +00:00
myObj.myThirdKey = true;
2014-10-30 18:58:59 +00:00
// При попытке доступа к атрибуту, который до этого не был создан, будет
// возвращен undefined
2014-10-30 15:04:56 +00:00
myObj.myFourthKey; // = undefined
///////////////////////////////////
// 3. Логика и Управляющие структуры
2014-10-30 15:04:56 +00:00
2014-11-01 19:54:49 +00:00
// Синтаксис управляющих структур очень похож на его реализацию в Java.
2014-10-30 15:04:56 +00:00
2014-11-01 19:54:49 +00:00
// if работает так как вы ожидаете.
2014-10-30 15:04:56 +00:00
var count = 1;
if (count == 3){
2014-11-01 19:54:49 +00:00
// выполнится, если значение count равно 3
2014-10-30 15:04:56 +00:00
} else if (count == 4){
2014-11-01 19:54:49 +00:00
// выполнится, если значение count равно 4
2014-10-30 15:04:56 +00:00
} else {
// выполнится, если значение count не будет равно ни 3 ни 4
2014-10-30 15:04:56 +00:00
}
2014-11-01 19:54:49 +00:00
// Поведение while тоже вполне предсказуемо
2014-10-30 15:04:56 +00:00
while (true){
2014-11-01 19:54:49 +00:00
// Бесконечный цикл
2014-10-30 15:04:56 +00:00
}
2014-11-01 19:54:49 +00:00
// Циклы do-while похожи на while, но они всегда выполняются хотябы 1 раз.
2014-10-30 15:04:56 +00:00
// Do-while loops are like while loops, except they always run at least once.
var input
do {
input = getInput();
} while (!isValid(input))
// Цикл for такой же как в C и Java:
2014-11-01 19:54:49 +00:00
// инициализация; условие продолжения; итерация
2014-10-30 15:04:56 +00:00
for (var i = 0; i < 5; i++){
2014-11-01 19:54:49 +00:00
// выполнится 5 раз
2014-10-30 15:04:56 +00:00
}
2014-11-01 19:54:49 +00:00
// && - логическое и, || - логическое или
if (house.size == "big" && house.color == "blue"){
2014-10-30 15:04:56 +00:00
house.contains = "bear";
}
2014-11-01 19:54:49 +00:00
if (color == "red" || color == "blue"){
// если цвет или красный или синий
2014-10-30 15:04:56 +00:00
}
2014-11-01 19:54:49 +00:00
// && и || удобны для установки значений по умолчанию.
2014-10-30 15:04:56 +00:00
// && and || "short circuit", which is useful for setting default values.
var name = otherName || "default";
// выражение switch проверяет равество с помощью ===
// используйте 'break' после каждого case,
2014-11-01 19:54:49 +00:00
// иначе помимо правильного case выполнятся и все последующие.
grade = '4'; // оценка
2014-10-30 15:04:56 +00:00
switch (grade) {
2014-11-01 19:54:49 +00:00
case '5':
console.log("Великолепно");
2014-10-30 15:04:56 +00:00
break;
2014-11-01 19:54:49 +00:00
case '4':
console.log("Неплохо");
2014-10-30 15:04:56 +00:00
break;
2014-11-01 19:54:49 +00:00
case '3':
console.log("Можно и лучше");
2014-10-30 15:04:56 +00:00
break;
default:
2014-11-01 19:54:49 +00:00
console.log("Да уж.");
2014-10-30 15:04:56 +00:00
break;
}
///////////////////////////////////
// 4. Функции, Область видимости и Замыкания
2014-10-30 15:04:56 +00:00
// Функции в JavaScript объявляются с помощью ключевого слова function.
2014-10-30 15:04:56 +00:00
function myFunction(thing){
return thing.toUpperCase(); // приведение к верхнему регистру
2014-10-30 15:04:56 +00:00
}
myFunction("foo"); // = "FOO"
// Помните, что значение, которое должно быть возкращено должно начинаться
// на той же строке, где расположено ключевое слово 'return'. В противном случае
// будет возвращено undefined. Такое поведения объясняется автоматической
// вставкой разделителей ';'. Помните этот факт, если используете
// BSD стиль оформления кода.
2014-10-30 15:04:56 +00:00
// 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 // <- разделитель автоматически будет вставлен здесь
2014-10-30 15:04:56 +00:00
{
thisIsAn: 'object literal'
}
}
myFunction(); // = undefined
// Функции в JavaScript являются объектами, поэтому их можно назначить в
// переменные с разными названиями и передавать в другие функции, как аргументы,
// на пример, при указании обработчика события.
2014-10-30 15:04:56 +00:00
function myFunction(){
// этот фрагмент кода будет вызван через 5 секунд
2014-10-30 15:04:56 +00:00
}
setTimeout(myFunction, 5000);
// Обратите внимание, что setTimeout не является частью языка, однако он
// доступен в API браузеров и Node.js.
2014-10-30 15:04:56 +00:00
// Объект функции на самом деле не обязательно объявлять с именем - можно
// создать анонимную функцию прямо в аргументах другой функции.
2014-10-30 15:04:56 +00:00
setTimeout(function(){
// этот фрагмент кода будет вызван через 5 секунд
2014-10-30 15:04:56 +00:00
}, 5000);
// В JavaScript есть области видимости. У функций есть собственные области
// видимости, у других блоков их нет.
2014-10-30 15:04:56 +00:00
if (true){
var i = 5;
}
i; // = 5, а не undefined, как это было бы в языке, создающем
// области видисти для блоков кода
2014-10-30 15:04:56 +00:00
// Это привело к появлению паттерна общего назначения "immediately-executing
// anonymous functions" (сразу выполняющиеся анонимные функции), который
// позволяет предотвратить запись временных переменных в общую облать видимости.
2014-10-30 15:04:56 +00:00
(function(){
var temporary = 5;
// Для доступа к глобальной области видимости можно использовать запись в
// некоторый 'глобальный объект', для браузеров это 'window'. Глобальный
// объект может называться по-разному в небраузерных средах, таких Node.js.
2014-10-30 15:04:56 +00:00
window.permanent = 10;
})();
temporary; // вызывает исключение ReferenceError
2014-10-30 15:04:56 +00:00
permanent; // = 10
// Одной из сильных сторон JavaScript являются замыкания. Если функция
// объявлена в внутри другой функции, внутренняя функция имеет доступ ко всем
// переменным внешней функции, даже после того, как внешняя функции завершила
// свое выполнение.
2014-10-30 15:04:56 +00:00
function sayHelloInFiveSeconds(name){
var prompt = "Привет, " + name + "!";
// Внутренние функции помещаются в локальную область видимости, как-будто
// они объявлены с ключевым словом 'var'.
2014-10-30 15:04:56 +00:00
function inner(){
alert(prompt);
}
setTimeout(inner, 5000);
// setTimeout является асинхроннной, и поэтому функция sayHelloInFiveSeconds
// завершит свое выполнение сразу и setTimeout вызовет inner позже.
// Однако, так как inner "закрыта внутри" или "замкнута в"
// sayHelloInFiveSeconds, inner все еще будет иметь доступ к переменной
// prompt, когда будет вызвана.
2014-10-30 15:04:56 +00:00
}
sayHelloInFiveSeconds("Вася"); // откроет модальное окно с сообщением
// "Привет, Вася" по истечении 5 секунд.
2014-10-30 15:04:56 +00:00
///////////////////////////////////
// 5. Немного еще об Объектах. Конструкторы и Прототипы
2014-10-30 15:04:56 +00:00
// Объекты могут содержать функции
2014-10-30 15:04:56 +00:00
var myObj = {
myFunc: function(){
return "Hello world!";
}
};
myObj.myFunc(); // = "Hello world!"
2014-11-01 22:12:22 +00:00
// Когда функции прикрепленные к объекту вызываются, они могут получить доступ
// к данным объекта, ипользуя ключевое слово this.
2014-10-30 15:04:56 +00:00
myObj = {
myString: "Hello world!",
myFunc: function(){
return this.myString;
}
};
myObj.myFunc(); // = "Hello world!"
2014-11-01 22:12:22 +00:00
// Содержание this определяется исходя из того, как была вызвана функция, а
// не места её определения. По этой причине наша функция не будет работать вне
// контекста объекта.
2014-10-30 15:04:56 +00:00
var myFunc = myObj.myFunc;
myFunc(); // = undefined
2014-11-01 22:12:22 +00:00
// И напротив, функция может быть присвоена объекту и получить доступ к нему
// через this, даже если она не была прикреплена к объекту в момент её создания.
2014-10-30 15:04:56 +00:00
var myOtherFunc = function(){
return this.myString.toUpperCase();
}
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "HELLO WORLD!"
2014-11-01 22:12:22 +00:00
// Также можно указать контекс выполнения фунции с помощью 'call' или 'apply'.
2014-10-30 15:04:56 +00:00
var anotherFunc = function(s){
return this.myString + s;
}
anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
2014-11-01 22:12:22 +00:00
// Функция 'apply' очень похожа, но принимает массив со списком аргументов.
2014-10-30 15:04:56 +00:00
anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
2014-11-01 22:12:22 +00:00
// Это может быть удобно, когда работаешь с фунцией принимающей на вход
// последовательность аргументов и нужно передать их в виде массива.
2014-10-30 15:04:56 +00:00
Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (uh-oh!)
Math.min.apply(Math, [42, 6, 27]); // = 6
2014-11-01 22:12:22 +00:00
// Однако, 'call' и 'apply' не имеют постоянного эффекта. Если вы хотите
// зафиксировать контекст для функции, используйте bind.
2014-10-30 15:04:56 +00:00
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
// bind также можно использовать чтобы частично передать аргументы в
2014-11-01 22:12:22 +00:00
// функцию (каррировать).
2014-10-30 15:04:56 +00:00
var product = function(a, b){ return a * b; }
var doubler = product.bind(this, 2);
doubler(8); // = 16
2014-11-01 22:12:22 +00:00
// Когда функция вызывается с ключевым словом new, создается новый объект.
// Данный объект становится доступным функции через ключевое слово this.
// Функции спроектированные вызываться таким способом называются конструкторами.
2014-10-30 15:04:56 +00:00
var MyConstructor = function(){
this.myNumber = 5;
}
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
// Любой объект в JavaScript имеет 'прототип'. Когда вы пытаетесь получить
// доступ к свойству не объявленному в данном объекте, интерпретатор будет
// искать его в прототипе.
2014-10-30 15:04:56 +00:00
2014-11-01 22:12:22 +00:00
// Некоторые реализации JS позволяют получить доступ к прототипу с помощью
// "волшебного" свойства __proto__. До момента пока оно не являются стандартным,
2014-11-01 22:12:22 +00:00
// __proto__ полезно лишь для изучения прототипов в JavaScript. Мы разберемся
// со стандартными способами работы с прототипом несколько позже.
2014-10-30 15:04:56 +00:00
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!"
// Естественно, если в свойства нет в прототипе, поиск будет продолжен в
// прототипе прототипа и так далее.
2014-10-30 15:04:56 +00:00
myPrototype.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
2014-11-01 22:12:22 +00:00
// Ничего не копируется, каждый объект хранит ссылку на свой прототип. Если
// изменить прототип, все изменения отразятся во всех его потомках.
2014-10-30 15:04:56 +00:00
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
2014-11-01 22:12:22 +00:00
// Как было сказано выше, __proto__ не является стандартом, и нет стандартного
// способа изменить прототип у созданного объекта. Однако, есть два способа
// создать объект с заданным прототипом.
2014-10-30 15:04:56 +00:00
2014-11-01 22:12:22 +00:00
// Первый способ - Object.create, был добавлен в JS относительно недавно, и
// потому не доступен в более ранних реализациях языка.
2014-10-30 15:04:56 +00:00
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
2014-11-01 22:12:22 +00:00
// Второй вариан доступен везде и связан с конструкторами. Конструкторы имеют
// свойство prototype. Это вовсе не прототип функции конструктора, напротив,
2014-11-01 22:12:22 +00:00
// это прототип, который присваевается новым объектам, созданным с этим
// конструктором с помощью ключевого слова new.
2014-10-30 15:04:56 +00:00
MyConstructor.prototype = {
myNumber: 5,
getMyNumber: function(){
return this.myNumber;
}
};
var myNewObj2 = new MyConstructor();
myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6
myNewObj2.getMyNumber(); // = 6
2014-11-01 22:12:22 +00:00
// У встроенных типов таких, как строки и числа, тоже есть конструкторы,
// создающие эквивалентные объекты-обертки.
2014-10-30 15:04:56 +00:00
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
2014-11-01 22:12:22 +00:00
// Правда, они не совсем эквивалентны.
2014-10-30 15:04:56 +00:00
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0){
2014-11-01 22:12:22 +00:00
// Этот фрагмент кода не будет выпонен, так как 0 приводится к false
2014-10-30 15:04:56 +00:00
}
if (Number(0)){
2014-11-01 22:12:22 +00:00
// Этот фрагмент кода *будет* выпонен, так как Number(0) приводится к true.
2014-10-30 15:04:56 +00:00
}
2014-11-01 22:12:22 +00:00
// Однако, оберточные объекты и обычные встроенные типы имеют общие прототипы,
// следовательно вы можете расширить функциональность строки, например.
2014-10-30 15:04:56 +00:00
String.prototype.firstCharacter = function(){
return this.charAt(0);
}
"abc".firstCharacter(); // = "a"
2014-11-01 22:12:22 +00:00
// Этот факт часто используется для создания полифилов(polyfill) - реализации
// новых возможностей JS в его более старых версиях для того чтобы их можно было
2014-11-01 22:12:22 +00:00
// использовать в устаревших браузерах.
2014-10-30 15:04:56 +00:00
2014-11-01 22:12:22 +00:00
// Например, мы упомянули, что Object.create не доступен во всех версиях
2014-11-13 08:32:51 +00:00
// JavaScript, но мы можем создать полифилл.
if (Object.create === undefined){ // не переопределяем, если есть
2014-10-30 15:04:56 +00:00
Object.create = function(proto){
2014-11-01 22:12:22 +00:00
// создаем временный конструктор с заданным прототипом
2014-10-30 15:04:56 +00:00
var Constructor = function(){};
Constructor.prototype = proto;
2014-11-01 22:12:22 +00:00
// создаём новый объект с правильным прототипом
2014-10-30 15:04:56 +00:00
return new Constructor();
}
}
```
2014-11-13 08:32:51 +00:00
## Что еще почитать
2014-10-30 15:04:56 +00:00
2014-11-13 08:32:51 +00:00
[Современный учебник JavaScript](http://learn.javascript.ru/) от Ильи Кантора
является довольно качественным и глубоким учебным материалом, освещающим все
особенности современного языка. Помимо учебника на том же домене можно найти
[перевод спецификации ECMAScript 5.1](http://es5.javascript.ru/) и справочник по
возможностям языка.
2014-10-30 15:04:56 +00:00
2014-11-13 08:32:51 +00:00
[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) позволяет
довольно быстро изучить основные тонкие места в работе с JS, но фокусируется
только на таких моментах
2014-10-30 15:04:56 +00:00
2014-11-13 08:32:51 +00:00
[Справочник](https://developer.mozilla.org/ru/docs/JavaScript) от MDN
(Mozilla Development Network) содержит информацию о возможностях языка на
английском.
2014-10-30 15:04:56 +00:00
2014-11-13 08:32:51 +00:00
Название проекта ["Принципы написания консистентного, идиоматического кода на
JavaScript"](https://github.com/rwaldron/idiomatic.js/tree/master/translations/ru_RU)
говорит само за себя.
2014-10-30 15:04:56 +00:00