Применяем продвинутые техники для улучшения вашего JavaScript кода

В этой статье мы рассмотрим самые распространённые техники и шаблоны, применив которые, вы сможете сделать ваш код более изящным и компактным. Для освоения данного урока, вам необходимы базовые знания JS и опыт работы с регулярными выражениями.

Длинные условные выражения

Первый рецепт, который мы рассмотрим, поможет сократить размер условных выражений if. Идея заключается в том, чтобы заменить логические операторы на простые регулярные выражения:

Если вы данную задачу обычно решаете таким образом:

if (val == 'a' || val == 'b' || val == 'c')

Знайте, что то же самое может быть записано вот в таком виде:

Следующий случай, с которым вам наверняка приходилось сталкиваться, это применение логического оператора:

if (a == 1 && b == 2 && c == 3 && d == 4 && e == 5)

Если у вас огромное число переменных, которые нужно проверить, вы можете создать специальный массив с именами переменных, второй массив с ожидаемыми значениями, и применить метод every. Метод every возвращает true, если проверяемые значения совпадают:

var vars = [a,b,c,d,e],
    vals = [1,2,3,4,5];

if (vals.every(function(val,i){ return vars[i] == val }))

Этот же пример можно ещё больше абстрагировать:

function isTrue(vars, vals) {
  return vals.every(function(val,i){ return vars[i] == val });
}

if (isTrue([a,b,c,d,e], [1,2,3,4,5]))

Для точно такой же проверки с применением логического оператора OR воспользуйтесь методом some, который возвращает true, если хотя бы одно выражение совпало. Однако такие выражения используются редко. Гораздо чаще нам могут встретиться условия с чередованием обоих логических операторов:

if (a == 1 && b == 2 || c == 3 && d == 4 || e == 5 && f == 6)

В этом случае стандартный подход лучший.

Работа с текстом

По сравнению с другими языками, JavaScript содержит небольшое количество функций для работы со строками. Представьте ситуацию: у нас есть параграф, где все предложения разделены точками. Мы хотим каждую букву каждого первого слова предложения сделать заглавной. С помощью циклов и некоторых строковых функций данная задача решается так:

var str = 'the sky is blue. apples are green.';

var para = str.split('.'), // получаем массив предложений
    i = 0, len = para.length, p;

for (; i < len; i++) {
  p = para[i].trim(); // удаляем все лишние пробелы
  para[i] = p.substr(0,1).toUpperCase() + p.substr(1, p.length);
}

para = para.join('. ').trim(); // склеиваем всё обратно

console.log(para);
//^ "The sky is blue. Apples are green."

Для оптимизации данного примера воспользуемся регулярными выражениями:

str = str.replace(/([^.]+\.\s?)/g, function(_, para) {
  return para.replace(/^\w/, function(first) {
    return first.toUpperCase();
  });
});

console.log(str);
// ^ "The sky is blue. Apples are green."

Другой пример: нам необходимо извлечь из строки все телефонные номера. Предположим, что перед каждым из них есть префикс “tel:”. Это поможет нам извлечь только номера телефонов. Все остальные цифры в строках затронуты не будут. В данном примере лучшим решением может быть применение регулярных выражений, и поскольку телефонов может быть несколько, нам необходимо написать глобальное регулярное выражение. Сначала попробуем применить метод match:

var str = 'Jerry, 26 years old, tel: 555-000-0000. Joy, 19 years old, tel:777-000-0000.';
var numbers = str.match(/tel:\s?([\d-]+)/g);
console.log(numbers); //=> ["tel: 555-000-0000", "tel:777-000-0000"]

Как вы уже заметили, в результате наши номера записались вместе с префиксом “:tel”. Дело в том, что match не записывает найденные значения в группы. Данный функционал доступен в методе exec.

var re = /tel:\s?([\d-]+)/g,
    numbers = [], match;

while (match = re.exec(str)) {
  numbers.push(match[1]);
}

console.log(numbers); //=> ["555-000-0000", "777-000-0000"]

Данный способ не является единственным возможным решением данной задачи. Также мы можем воспользоваться методом replace, который принимает функцию, в которую мы передаём саму строку. Все дальнейшие параметры указывают на различные группы захвата:

var numbers = [];
str.replace(/tel:\s?([\d\-]+)/g, function(_, number) {
  numbers.push(number);
});

console.log(numbers); //=> ["555-000-0000", "777-000-0000"]

Также мы можем объявить свой собственный метод gmatch и, в дальнейшем, им пользоваться.

String.prototype.gmatch = function(regex) {
  var result = [];
  this.replace(regex, function() {
    // extract matches by removing arguments we don't need
    var matches = [].slice.call(arguments, 1).slice(0,-2);
    result.push.apply(result, matches);
  });
  return result;
};

console.log(str.gmatch(/tel:\s?([\d\-]+)/g)) //=> ["555-000-0000", "777-000-0000"]

Теперь наш код смотрится намного лучше!

Генерация HTML кода

Если вы много работаете с JavaScript-ом, то наверняка вам довольно-таки часто приходится генерировать каике-то списки, таблицы и прочие элементы. Обычно для этого используется вот такая техника:

var values = ['one', 'two', 'three', 'four', 'five'];

var html = '';
for (var i = 0; i < values.length; i++) {
  html += '<td>'+ values[i] +'</td>';
}

Данный пример решает нашу задачу, но выглядит не очень хорошо. Для более изящного решения, воспользуемся методом join:

var html = '<td>'+ values.join('</td><td>') +'</td>';

Отлично! Но что, если нам нужен индекс? В этом случае, можем скомбинировать работу методов map и join:

var html = values.map(function(text, i) {
  return '<td>'+ text +': '+ i +'</td>'
}).join('');

Когда задачи усложняются, нам приходится писать всё больше и больше циклов для отдельных разъединённых HTML фрагментов кода. Для решения данной проблемы можем воспользоваться техникой написания шаблонов. Давайте напишем очень простого “помощника”, которого будем использовать для работы с шаблонами:

function template(arr, html) {
  return arr.map(function(obj) {
    return html.join('').replace(
      /#\{(\w+)\}/g,
      function(_, match) { return obj[match]; }
    );
  }).join('');
}

Его мы можем использовать следующим образом:

var people = [
  { name: 'John', age: 25, status: 'Single' },
  { name: 'Bill', age: 23, status: 'Married' },
  { name: 'Mika', age: 17, status: 'Single' }
];

var html = template(people, [
  '<div>',
    '<h1>Name: #{name}</h1>',
    '<h2>Age: #{age}, Status: #{status}</h2>',
  '</div>'
]);

console.log(html);
// ^
// "<div><h1>Name: John</h1><h2>Age: 25, Status: Single</h2></div>\
// <div><h1>Name: Bill</h1><h2>Age: 23, Status: Married</h2></div>\
// <div><h1>Name: Mika</h1><h2>Age: 17, Status: Single</h2></div>"

Данный способ позволяет нам генерировать HTML фрагменты кода вот таким вот изящным способом.

Используем функциональный код

JavaScript позволяет нам писать функциональный код, который мы можем использовать для написания более компактных скриптов. Примеры этому вы можете увидеть выше.

Все последние браузеры, включая IE9, поддерживают методы EcmaScript5, однако, многим из них мы можем найти альтернативу.

Одним из преимуществ обработки функции в цикле является возможность создания новой области видимости. Это может пригодиться, когда мы запускаем асинхронный код внутри цикла. Представьте ситуацию:

var arr = ['a','b','c'];
for (var i = 0; i < arr.length; i++) {
  setTimeout(function() { console.log(arr[i] +':'+ i); }, i * 1000);
}

Данный код по идее должен выдать результат a:0..b:1..c:2. Вместо этого мы увидим undefined:3..undefined:3..undefined:3. Типичным решением данной проблемы будет создание новой области видимости:

var arr = ['a','b','c'];
for (var i = 0; i < arr.length; i++) {
  setTimeout(function(i) { console.log(arr[i] +':'+ i); }(i), i * 1000);
}

Теперь же результат будет такой, как мы ожидаем, однако данный код может немного запутать. Всё становится гораздо понятнее, если мы воспользуемся циклом forEach, который самостоятельно создаёт новую область видимости:

arr.forEach(function(v, i) {
  setTimeout(function() { console.log(v +':'+ i); }, i * 1000);
});

Когда мы имеем дело с большими объёмами данных, функциональный подход - это лучший способ улучшить читабельность. Пример:

var users = [
  {
    name: 'Fred',
    age: 25,
    job: 'Developer',
    membership: 'Gold'
  },
  {
    name: 'John',
    age: 28,
    job: 'Cook',
    membership: 'Platinum'
  },
  {
    name: 'Zoe',
    age: 32,
    job: 'Make-up artist',
    membership: 'Silver'
  },
  {
    name: 'Louise',
    age: 35,
    job: 'Cook',
    membership: 'Silver'
  }
];

Благодаря методам, применяемым к массивам, мы можем извлечь практически любую нужную нам информацию по определённому критерию:

var over30 = users.filter(function(user) {
  return user.age >= 30;
});

var cooks = users.filter(function(user) {
  return user.job == 'Cook';
});

Данный код смотрится неплохо, однако при большом количестве операций он будет дублировать неоднократно. Это нас не устраивает, и поэтому мы объявим и реализуем специальный прототипы функций и применим уже изученные нами техники для того, чтобы иметь возможность писать вот такой изящный код:

var over30 = users.where('age').is('>=30');
var cooks = users.where('job').is('Cook');

Для понимания следующего кода, вам потребуются хорошее понимание функционального программирования в JavaScript. Надеюсь, комментарии помогут вам разобраться:

// Используем непосредственно выполняемую функцию-выражение (Immediately Invoked Function Expression - IIFE)
// для устранения возможных конфликтов переменных
(function(win) {

  // Основной конструктор для объекта MyStorage
  function MyStorage(data) {
    this.data = data; // массив для наших данных
    this.length = this.data.length; // размер массива
  }

  // Метод для создания новых объектов MyStorage
  function stored(data) {
    return new MyStorage(data);
  }

  // Очень простой метод для присвоения полей одного объекта другому
  function _extend(obj, target) {
    for (var o in obj) target[o] = obj[o];
    return target;
  }

  MyStorage.prototype = {

    // Private:

    // Обновить данный и вернуть новый объект.
    // Нам необходимо клонировать объект
    // иначе он будет передаваться по ссылке
    _new: function(result) {
      result = result.map(function(o) { return _extend(o, {}); });
      this.length = this.data.length;
      return stored(result);
    },

    // Фильтруем текущее поле объекта в специальной функции.
    // Поле передаём как параметр в 'fn' функцию обратного вызова
    _filter: function(fn) {
      return this._new(this.data.filter(function(user, i) {
        return fn.call(this, user[this.prop], i);
      }.bind(this)));
    },

    // Public:

    // Возвращаем массив со специфическими полями от каждого объекта
    // или коллекцию объектов
    get: function(prop) {
      if (prop) return this.map(function() { return this[prop]; });
      return this.data;
    },

    // Установка на фильтрацию или сравнение
    where: function(prop) {
      return this.prop = prop, this;
    },

    // Создаём добавочное условие
    and: function(prop) { return this.where(prop); },

    // Проверка значения поля и представленного условия
    is: function(condition) {
      // Фильтруем через регулярное выражение или строку/цифру
      var regex = condition instanceof RegExp ? condition :
        new RegExp('^'+ condition +'$');

      // Извлекаем символ сравнения. К примеру, из строк вида '>50' и '<=10'.
      // 'null' и '0' возвращаются по умолчанию, если
      // строка не содержит символ
      var symbol = (/^([<>=%]+)([\d.]+)/.exec(condition) || [0,null,0]);

      // Сработает, если символ сравнения был задан
      if (symbol[1]) return this[symbol[1]](+symbol[2]);

      return this._filter(function(prop) {
        return regex.test(prop);
      });
    },

    '>': function(v) {
      return this._filter(function(p) { return p > v; });
    },

    '>=': function(v) {
      return this._filter(function(p) { return p >= v; });
    },

    '<': function(v) {
      return this._filter(function(p) { return p < v; });
    },

    '<=': function(v) {
      return this._filter(function(p) { return p <= v; });
    },

    '%': function(v) {
      return this._filter(function(p) { return p % v === 0; });
    },

    // Сортировать коллекцию заданной функцией
    // и вернуть новую инстанцию Templee
    sort: function(fn) {
      return this._new(this.data.sort(function() {
        return fn.apply(this, [].slice.call(arguments));
      }.bind(this)));
    },

    // Фильтруем коллекцию по индексу
    eq: function(index) {
      return this._new(this.data[index]);
    }

  };

  // Перенимаем встроенные методы
  'forEach map slice every some reduce'.split(' ').forEach(function(method) {
    MyStorage.prototype[method] = function(fn) {
      return this.get()[method](function() {
        return fn.apply(arguments[0], [].slice.call(arguments));
      }.bind(this));
    };
  });

  win.stored = stored; // даём пользователю возможность работать с конструктором

}(window));

Применение Storage, очень похоже на использование jQuery:
stored(users)
  .where('age').is('>30')
  .and('job').is('Cook').forEach(function(user) {
    console.log(user.name); // Louise
  });

Теперь представьте, что мы можем творить благодаря системе шаблонов, которые создали ранее:

var movies = [
  { title: 'Spiderman', score: 7, gross: 90e6 },
  { title: 'Aliens vs Predators', score: 5 , gross: 50e6 },
  { title: 'American Beauty', score: 9.5 , gross: 140e6 },
  { title: '500 Days of Summer', score: 8.5 , gross: 75e6 },
  { title: 'Drive', score: 7.5 , gross: 120e6 },
  { title: '127 Hours', score: 9 , gross: 78e6 }
];

var myMovies = stored(movies);

var featured = template(myMovies.where('score').is('>=8').get(), [
  '<div class="featured-movie">',
    '<h2>#{title}</h2>',
    '<h3>Score: #{score}, Gross: #{gross}</h3>',
  '</div>'
]);

var bigGross = template(myMovies.where('gross').is('>80000000').get(), [
  '<ul class="big-gross-movies">',
    '<li>#{title} <span class="gross">#{gross}</span></li>',
  '</ul>'
]);

$('body').append([
  '<h1>Featured Movies:</h1>'+ featured,
  '<h1>Big Gross Movies:</h1>'+ bigGross,
].join(''));

Также возможны и более сложные варианты:

// Найти все названия фильмов, начинающихся с цифры
myMovies.where('title').is(/^\d/).get('title'); //=> ["127 Hours", "500 Days of Summer"]

// Цепочки
myMovies.where('gross').is('>100000000')
  .and('score').is('>9').get('title') //=> ["American Beauty"]

Также мы можем применять к нашим объектам методы forEach, map, slice, every, some, reduce:

// Выводит по одному названию фильма за секунду
myMovies.forEach(function() {
  setTimeout(function() { console.log(this.title) }.bind(this), 1000);
});

Итоги

Применяя функциональные техники, мы можем сделать наш код чистым и больше похожим на модульный. Такие фрэймворки, как jQuery и Zepto, применяют подобные методы программирования.

Источник: http://feedproxy.google.com/~r/ruseller/CdHX/~3/rKXRVfRRdTE/lessons.php

Читать комменты и комментировать

Добавить комментарий / отзыв



Защитный код
Обновить

Применяем продвинутые техники для улучшения вашего JavaScript кода | | 2013-03-29 00:50:17 | | Статьи Web-мастеру | | В этой статье мы рассмотрим самые распространённые техники и шаблоны, применив которые, вы сможете сделать ваш код более изящным и компактным. Для освоения данного урока, вам необходимы базовые | РэдЛайн, создание сайта, заказать сайт, разработка сайтов, реклама в Интернете, продвижение, маркетинговые исследования, дизайн студия, веб дизайн, раскрутка сайта, создать сайт компании, сделать сайт, создание сайтов, изготовление сайта, обслуживание сайтов, изготовление сайтов, заказать интернет сайт, создать сайт, изготовить сайт, разработка сайта, web студия, создание веб сайта, поддержка сайта, сайт на заказ, сопровождение сайта, дизайн сайта, сайт под ключ, заказ сайта, реклама сайта, хостинг, регистрация доменов, хабаровск, краснодар, москва, комсомольск |
 
Поделиться с друзьями: