Лучше ли извлекать строковые литералы из констант в Javascript? - PullRequest
Новая
       3

Лучше ли извлекать строковые литералы из констант в Javascript?

5 голосов
/ 18 марта 2012

В Java я рекомендую заменять строковые литералы константной переменной каждый раз, когда они используются более чем в одном месте и ожидают совпадения. Например, если вы собираетесь установить cookie, а затем позже прочитать его, имя cookie должно быть постоянным, чтобы компилятор мог помочь вам отловить орфографические ошибки, не говоря уже о том, что у вас есть читаемое имя переменной по сравнению с фактическим значением строки.

Я рассматриваю некоторый код, подобный этому, в JavaScript, и я склонен рекомендовать заменить литералы константой. Тем не менее, я не уверен, что применимы те же причины, поскольку здесь нет компилятора, а имя файла cookie является таким же описательным, как и имя переменной.

Редактировать: Относительно комментариев и ответов, полученных до сих пор, я определенно больше обеспокоен использованием констант по сравнению с тем, как они на самом деле реализованы. Я вижу их значение в Java и других скомпилированных языках как способ предотвращения ошибок, но я не уверен, что вижу такое же значение в Javascript.

Как механизм документирования, скажем, для магических чисел, я думаю, что именованная переменная (даже если она не применяется как константа) все еще является хорошим способом улучшить читаемость. Но для строковых литералов я не уверен в этом: 

var trackingCookieName = "trackingCookie";

лучше, чем просто использовать «trackingCookie», поскольку вы можете опечатывать либо литерал, либо имя переменной, и в любом случае он будет перехвачен только во время выполнения.

Ответы [ 7 ]

8 голосов
/ 16 сентября 2013

Извлечение строковых литералов в константы означает

  • Такие инструменты, как JSHint, могут определять имена переменных с ошибками
  • Компрессоры могут сокращать имена переменных для меньшего вывода
  • Вы изменяете значения строкировно в 1 месте
6 голосов
/ 18 марта 2012

Ответ субъективен. как вы написали, компилятора или констант нет.

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

1 голос
/ 08 июня 2012

ОК, я согласен, что это может быть субъективным выбором.Вот причины, по которым я склонен использовать что-то, эквивалентное константам в JavaScript.Во-первых, вот как я могу определить свои константы (или они больше похожи на ENUM): 

function ENUM(name) {
  window[name] = name; // depending on platform I am on
}

Затем в глобальной области видимости, возможно, в каком-то файле, я делаю 

ENUM("MSG_DOOR_OPEN");
ENUM("MSG_DOOR_CLOSED");

И я использую это в своем коде как: 

obj.notify(MSG_DOOR_OPEN);

Причина, по которой мне это нравится больше:

  1. Если я что-то неправильно пишу, я получаю некоторую неопределенную ошибку ссылки, которая делаетэто очень легко обнаружить в любой консоли JavaScript.
  2. Таким образом, я имею в виду предварительно выделенный строковый объект, а не создаю новый строковый объект.
  3. Мне не нужно цитироватьвещь - выглядит лучше, особенно в vim.

Недостатки:

  1. Да, это глобальная переменная.
  2. Не разделено именами (кроме префикса MSG_).
  3. Это хлопотно, если вы хотите сделать это для всего.(вам не нужно)

Но для таких важных вещей, как имена сообщений и т. д., мне нравится делать это так.Кроме того, все имена сообщений, определенные в 1 месте, в любом случае хороши.Я не эксперт по JavaScript или что-то еще, поэтому, пожалуйста, поправьте меня, если я ошибаюсь ...

1 голос
/ 18 марта 2012

Я согласен с Гдороном, когда он говорит, что это субъективно, на самом деле то, что мы называем соглашениями для языков программирования, на самом деле является соглашением между разработчиками о том, как с их точки зрения код будет более понятным, проще в обслуживании и т. Д. 1001 *

Я привел понятие "условность", потому что это понятие "const" в значительной степени связано с этим, и есть некоторые люди / организации, которые часто используют эти языки и определяют для них некоторые хорошие практики. Вы можете использовать эти условные обозначения так, как вам больше подходит, потому что они немного отличаются между собой, поэтому вы можете адаптироваться по мере накопления опыта. Вот они:

Руководство по стилю Google

JS Crockford Style Guide

1 голос
/ 18 марта 2012

Javascript const широко не поддерживается, поэтому я бы сказал, Нет , это не лучшая практика.

"Текущая реализация const является специфичным для Mozilla расширением и не является частью ECMAScript 5. Она поддерживается в Firefox & Chrome (V8) и частично поддерживается в Opera 9+ и Safari. Она не поддерживается в Internet Explorer 6-9, или в предварительном просмотре Internet Explorer 10. Ключевое слово const в настоящее время объявляет константу в области действия функции (как переменные, объявленные с помощью var).

const будет определен в ECMAScript 6, но с другой семантикой. Подобно переменным, объявленным с помощью оператора let, константы, объявленные с помощью const, будут иметь область видимости блока. "- https://developer.mozilla.org/en/JavaScript/Reference/Statements/const

Кроме того, если вы хотите реализовать истинное const в javascript, оберните его в объект и предоставьте только функциональность get.

Примерно так: 

var Cookies = (function()
{
 var consts = 
 {
  'APPLICATION': '21930857a3e',
  'SERVER': '435a3456jh5'
 };
 return
 {
  get: function(name)
  { 
   return consts [name];
  }
 };
}
)();

А затем получить их: 

document.write('<img src="' + Cookies.get('APPLICATION') + '" />')

или как вы хотите использовать константы.

0 голосов
/ 22 октября 2013

В обсуждении констант в JavaScript я лично предпочитаю следующий метод (который на самом деле ближе к перечислениям). 

var DIR = {
    North: [-1, 0],
    NorthEast: [-1, 1],
    East: [0, 1],
    SouthEast: [1, 1],
    South: [1, 0],
    SouthWest: [1, -1],
    West: [0, -1],
    NorthWest: [-1, -1]
};

, который облегчает его использование, например: 

var myDirection = DIR.SouthEast;

Кроме того, современные IDE могут предоставить Intellisense для значений, которые действительно помогают.

Другой метод, упомянутый @ Travis-J, хорош, и многие фреймворки его используют (Sencha и т. Д.),Но для чего-то, что близко к константе или перечислению в JS, я предпочитаю мой вышеописанный метод.

Но вы, безусловно, могли бы сделать это, как сказал Трэвис: 

var Directions = (function() {
    var consts = {
        'North': [-1, 0],
        'NorthEast': [-1, 1],
        'East': [0, 1],
        'SouthEast': [1, 1],
        'South': [1, 0],
        'SouthWest': [1, -1],
        'West': [0, -1],
        'NorthWest': [-1, -1]
    };

    return {
        get: function(name) {
            return consts[name];
        }
    }
})();

Но проблема у менятеперь вы должны знать правильные ключи.

var myDirection = Directions.get('SouthEast');
var myDirection = Directions.get('SOUTHEAST');  //  null

Надеюсь, это немного поможет.

0 голосов
/ 18 марта 2012

Использование констант всегда лучше, независимо от языка (хорошо, может быть, вы найдете хорошее исключение). Единственный раз, когда я использую строковые литералы, я делаю парсеры файлов или у меня мало времени, и я не хочу составлять список констант.

Конечно, слишком много констант может быть сложнее для чтения ... Это действительно зависит от того, насколько неясны строковые литералы.

Несмотря на это, Javascript - это язык, насыщенный строками (как любой интерпретируемый язык). Вы можете извлекать поля из объектов, основываясь на строковом имени объекта (container["innerObject"]), и выполнить код через строку почти слишком просто.

...