Reasoning

Identifiers of only 1 or 2 Characters can lead to errors in thought and poor
readability of code. I have a preference for identifiers that consist of 3 or
more characters and they are rarely that short.

An alternate enhancement is for support of single and double letter identifiers
when listed in /*global*/.

Just noticed that the highlighted is partially supported at least at the
global level. But does not catch nested vars.
So having the Identifier length limits would be good to hunt for those
left in code by peers.

--- In jslint_com@yahoogroups.com, "abyssoft@..." <abyssoft@...> wrote:
>
> Reasoning
>
> Identifiers of only 1 or 2 Characters can lead to errors in thought
and poor readability of code. I have a preference for identifiers that
consist of 3 or more characters and they are rarely that short.
>
> An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
>



[Non-text portions of this message have been removed]

What about this (very) common construct:

for (var i = 0; i < foo.length; i += 1) {}

I agree that very short identifiers are generally a bad idea, but I also think
there are a couple exceptions (like the above).

--- In jslint_com@yahoogroups.com, "abyssoft@..." <abyssoft@...> wrote:
>
> Reasoning
>
> Identifiers of only 1 or 2 Characters can lead to errors in thought and poor
readability of code. I have a preference for identifiers that consist of 3 or
more characters and they are rarely that short.
>
> An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
>

That is why I would like it as a switch/option not a requirement.

I would write

for (var i = 0; i < foo.length; i += 1) {}

as

var fooIndex;
for (fooIndex = foo.length -1 ; fooIndex + 1 ; fooIndex -= 1) {
     //Loop Content even if only a one liner.
}

I never declare vars in loops, or in the setup of a loop.

--- In jslint_com@yahoogroups.com, "pauanyu" <pcxunlimited@...> wrote:
>
>
>
> What about this (very) common construct:
>
> for (var i = 0; i < foo.length; i += 1) {}
>
> I agree that very short identifiers are generally a bad idea, but I also think
there are a couple exceptions (like the above).
>
> --- In jslint_com@yahoogroups.com, "abyssoft@" <abyssoft@> wrote:
> >
> > Reasoning
> >
> > Identifiers of only 1 or 2 Characters can lead to errors in thought and poor
readability of code. I have a preference for identifiers that consist of 3 or
more characters and they are rarely that short.
> >
> > An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
> >
>

Below is a comprehensive list of words that I consider as Reserved.  I use this
list to help keep me out of traps and bad Identifier choice. This also helps to
force me to be a bit more creative with my Identifier names, and as such opens
me up to more thoughtful solutions.
I use classes and classes that emulate namespaces and avoid global primitive
variables. If I should need a global scope variable I place as a field of a
Global namespace. I have found this helps to keep my code both clean and highly
readable.
Another tool I use as a complement to JSLint is JSDoc-Toolkit. It helps me with
organizing my code in to OOJS. Feel free to ask questions.

// RESERVED WORDS - Contains Reserve words from HTML Tags, common file
extensions,
// Java, JavaScript, Cobol, Fortran, C#, Basic (different flavors), VB.net, SQL
(different flavors),
// Browser names, Corporate entities, and others that interfere with
self-documenting code practices.
// Some Keyword from Java/JavaScript have been omitted as they are not legal
identifiers.
// Also keywords from various JavaScript libraries have been omitted and if need
should be in their own library declaration.
// (Reserved Words A-F)
/*global a, A, abstract, accept, Accept, add, Add, ADD, aggregate, Aggregate,
AGGREGATE, alert, all, All, ALL, alter, Alter, ALTER, amaya, Amaya, Anchor, and,
And, AND, any, Any, ANY, apple, Apple, Area, Arguments, array, Array, As, AS,
assign, Assign, at, At, AT, average, Average, AVERAGE, b, B, base, Base, begin,
Begin, BEGIN,big, Big, BIG, bigint, bigInt, Bigint, BigInt, BIGINT, bit, Bit,
BIT, blur, bool, Bool, boolean, Boolean, bottom, Bottom, Break, BREAK, browser,
Browser, BROWSER, bulk, Bulk, BULK, Button, by, By, BY, byte, Byte, c, C, cdata,
CDATA, cache, Cache, CACHE, callee, caller, camino, Camino, captureEvents,
cartesian, Cartesian, CARTESIAN, Case, CASE, cast, Cast, CAST, Catch, char,
Char, CHAR, CHARACTER, check, Check, Checkbox, checkBox, checked, Checked,
chrome, Chrome, Class, clearInterval, clearTimeout, clone, Clone, close, closed,
comment, commit, Commit, COMMIT, concat, Concat, CONCAT, confirm, Const,
constructor, Constructor, contains, Contains, CONTAINS, Continue, control,
Control, count, Count, COUNT, create, Create, CREATE, currency, Currency,
CURRENCY, d, D, data, Data, DATA, Date, date, datepart, datePart, Datepart,
DatePart, DATEPART, datetime, dateTime, Datetime, DateTime, DATETIME, decimal,
Decimal, DECIMAL, declare, Declare, def, Def, DEF, Default, defaultStatus,
delegate, Delegate, Delete, DELETE, dfn, Dfn, DFn DFN, dialog, Dialog, DIALOG,
dialogue, Dialogue, DIALOGUE, die, Die, dim, Dim, DIM, dimm, Dimm, DIMM
distinct, Distinct, DISTINCT, divide, Divide, DIVIDE, Do, document, Document,
double, Double, down, Down, dram, Dram, DRAM, drop, Drop, DROP, e, E, echo,
Echo, element, Element, Else, ELSE, elseif, elseIf, empty, Empty, end, End, END,
enddeclare, endDeclare, EndDeclare, endfor, endFor, EndFor, endforeach,
endforEach, endForeach, endForEach, Endforeach, EndforEach, EndForeach,
EndForEach, endif, endIf, EndIf, endwhile, endWhile, EndWhile, endwith, endWith,
Endwith, EndWith, ENDWITH, Enum, ENUM, enumeration, Enumeration, ENUMERATION,
epiphany, Epiphany, equal, Equal, EQUAL, escape, Eval, event, Event, exception,
Exception, except, Except, EXCEPT, exclude, Exclude, EXCLUDE, exit, Exit, EXIT,
explicit, Explicit, explorer, Explorer, Export, Extends, extern, Extern, f, F,
fact, Fact, FACT, False, file, File, FileUpload, final, Final, Finally, find,
Find, firefox, fireFox, FireFox, first, First, FIRST, fixed, Fixed, float,
Float, flock, Flock, focus, Focus, For, foreach, forEach, ForEach, Form, Frame,
frames, Frames, from, From, FROM, Function, FUNCTION */
// (Reserved Words G-M)
/*global g, G, geography, Geography, GEOGRAPHY, get, Get, GET, getClass, global,
go, Go, GO, google, Google, gosub, Gosub, goSub, GoSub, GOSUB, goto, Goto, GoTo,
GOTO, grant, Grant, GRANT, group, Group, GROUP, groupby, groupBy, Groupby,
GroupBy, GROUPBY, groupjoin, groupJoin, Groupjoin, GroupJoin, GROUPJOIN, h, H,
hash, Hash, HASH, hashtable, hashTable, Hashtable, HashTable, HASHTABLE, having,
Having, HAVING, Hidden, history, History, home, Home, html, Html, HTML, i, I,
icab, iCab, ICab, id, Id, ID, If, IF, image, Image, Implements, implicit,
Implicit, Import, IMPORT, imports, Imports, IMPORTS, In, include, Include,
INCLUDE, index, Index, INDEX, infinity, inherit, Inherit, init, Init, INIT,
innerHeight, innerWidth, input, Input, INPUT, insert, Insert, INSERT,
instanceOf, InstanceOf, int, Int, INT, int16, Int16, INT16, int32, Int32, INT32,
int64, Int64, INT64, integer, Integer, INTEGER, Interface, internal, Internal,
internet, Internet, internetExplorer, InternetExplorer, intersect, Intersect,
INTERSECT, into, Into, INTO, isFinite, IsFinite, isNaN, IsNaN, isset, isSet,
IsSet, j, J, java, Java, javaArray, JavaArray, javaClass, JavaClass, javaObject,
JavaObject, javaPackage, JavaPackage, join, join, JOIN, k, K, key, Key, KEY,
kmelon, k_melon, kMelon, k_Melon, KMelon, K_Melon, konqueror, Konqueror, l, L,
label, Label, LABEL, last, Last, LAST, left, Left, length, Length, Let, LET,
Link, link, list, List, location, Location, lock, Lock, locationbar, long, Long,
loop, Loop, LOOP, m, M, macro, Macro, MACRO, Math, math, min, Min, MIN, max,
Max, MAX, maxthon, Maxthon, menubar, merge, Merge, MERGE, method, Method,
METHOD, micro, Micro, MICRO, microsoft, microSoft, Microsoft, MicroSoft,
MimeType, mod, Mod, MOD, mode, Mode, MODE, modulus, moveBy, moveTo, multiply,
Multiply, MULTIPLY */
// (Reserved Words N-S)
/*global n, N, name, Name, namespace, Namespace, nameSpace, NameSpace, nan,
NATIONAL, native, Native, NATIVE, natural, Natural, NATURAL, navigate,
navigator, Navigator, nchar, Nchar, nChar, NChar, NCHAR, netscape, Netscape,
NetScape, netsurf, netSurf, NetSurf, New, next, Next, NEXT, no, No, NO, Null,
number, Number, NUMBER, numeric, Numeric, NUMERIC, nvarchar, nvarChar, nVarchar,
Nvarchar, NvarChar, NVarchar, NVarChar, NVARCHAR, o, O, object, Object, of, Of,
OF, off, Off, OFF, oftype, ofType, OfType, OFTYPE, omniweb, omniWeb, Omniweb,
Omniweb, on, On, ON, onBlur, onError, onFocus, onLoad, onUnload, open, Open,
OPEN, opener, opera, Opera, operator, Operator, option, Option, or, Or, OR,
oracle, Oracle, order, Order, ORDER, orderby, orderBy, Orderby, OrderBy,
ORDERBY, ordered, Ordered, out, Out, outerHeight, outerWidth, output, Output,
OUTPUT, overload, overLoad, override, overRide, p, P, Packages, pageXoffset,
pageYoffset, params, Params, parent, parseFloat, parseInt, password, Password,
pause, Pause, PAUSE, peek, Peek, PEEK, persistent, Persistent, PERSISTENT,
personalbar, personalBar, play, Play, PLAY, plugin, Plugin, poke, Poke, POKE,
precision, Precision, PRECISION, primary, Primary, PRIMARY, print, Print, PRINT,
Private, proc, Proc, PROC, procedure, Procedure, PROCEDURE, prom, Prom, PROM,
prompt, Prompt, Protected, prototype, Prototype, Public, q, Q,  quit, Quit,
QUIT, r, R, radio, Radio, ram, Ram, RAM, rate, Rate, RATE, read, Read, READ,
readonly, readOnly, ReadOnly, real, Real, REAL, redim, Redim, reDim, ReDim,
REDIM, ref, Ref, regexp, regExp, RegExp, releaseEvents, rem, Rem, REM, remark,
Remark, REMARK, rename, Rename, RENAME, repeat, Repeat, REPEAT, reset, Reset,
resizeBy, resizeTo, Return, RETURN, reverse, Reverse, REVERSE, revoke, Revoke,
REVOKE, right, Right, rollback, Rollback, rollBack, RollBack, ROLLBACK, rom,
Rom, ROM, routeEvent, run, Run, RUN, s, S, safari, Safari, save, Save, SAVE,
savepoint, Savepoint, savePoint, SavePoint, SAVEPOINT, sbyte, sByte, SByte,
scale, Scale, SCALE, scroll, scrollbars, scrollBy, scrollTo, sealed, Sealed,
seamonkey, seaMonkey, Seamonkey, SeaMonkey, small, Small, smallint, smallInt,
Smallint, SmallInt, SMALLINT, select, Select, SELECT, selectmany, selectMany,
Selectmany, SelectMany, SELECTMANY, self, Self, set, Set, SET, setInterval,
setTimeout, short, Short, sizeof, sizeOf, skip, Skip, SKIP, skipwhile,
skipWhile, Skipwhile, SkipWhile, SKIPWHILE, some, Some, SOME, sort, Sort, SORT,
sputnik, Sputnik, stackalloc, stackAlloc, start, Start, START, Static, status,
Status, statusbar, statusBar, stop, Stop, string, String, struct, Struct, sub,
Sub, SUB, submit, Submit, subtract, Subtract, SUBTRACT, sum, Sum, SUM, sun,
Super, swap, Swap, SWAP, Switch, sync, Sync, SYNC, synchronized, Synchronized */
// (Reserved Words S-Z)
/*global t, T, tab, Tab, TAB, table, Table, TABLE, taint, Taint, take, Take,
TAKE, takewhile, takeWhile, Takewhile, TakeWhile, TAKEWHILE, text, Text,
textarea, textArea, Textarea, TextArea, then, Then, THEN, thenby, thenBy,
Thenby, ThenBy, THENBY, This, through, Through, THROUGH, Throw, throws, Throws,
thru, Thru, THRU, time, Time, TIME, times, Times, TIMES, toolbar, toolBar,
Toolbar, ToolBar, top, Top, toString, transaction, Transaction, TRANSACTION,
transient, Transient, True, truncate, Truncate, TRUNCATE, Try, TRY, type, Type,
TYPE, typeOf, TypeOf, u, U, unescape, unEscape, Unescape, uint, uInt, UINT,
uint16, Uint16, UInt16, UINT16, uint32, Uint32, UInt32, UINT32, uint64, Uint64,
UInt64, UINT64, ulong, uLong, unchecked, unChecked, unit, Unit, UNIT, unordered,
unOrdered, Unordered, update, Update, UPDATE, unsafe, Unsafe, use, Use, ushort,
uShort, using, Using, untaint, unTaint, Untaint, until, Until, UNTIL, unwatch,
unWatch, UnWatch, Unwatch, v, V, value, Value, VALUE, values, Values, VALUES,
valueof, valueOf, Valueof, ValueOf, Var, VAR, varchar, Varchar, varChar,
VarChar, VARCHAR, variable, Variable, VARIABLE, variant, Variant, virtual,
Virtual, Void, VOID, w, W, wait, Wait, WAIT, watch, Watch, wend, Wend, WEND,
While, WHILE, when, When, WHEN, window, Window, With, work, Work, WORK, write,
Write, writeline, writeLine, Writeline, WriteLine, writeln, writeLn, Writeln,
WriteLn, x, X, xml, Xml, XML, xor, Xor, XOR, y, Y, yes, Yes, YES, zero, Zero,
ZERO */

Hi All:

On a bit of a tangent, there are no sigils in javascript, so therefore we use
RPN to indicate data types.  So my implementation would look something like
this:

var
   ary_foo = [ 'bing','bang','boom'],
   idx_foo
   ;

for ( idx_foo = 0; idx_foo < ary_foo.length; idx_foo++ ){ }

We have a comprehensive list of prefixes we currently use, if anyone is
interested.

Feedback and suggestions are welcome :)

Cheers, Mike




________________________________
From: "abyssoft@..." <abyssoft@...>
To: jslint_com@yahoogroups.com
Sent: Sun, July 4, 2010 3:11:36 PM
Subject: [jslint] Re: Enhancement Request: Identifier length restriction


That is why I would like it as a switch/option not a requirement.

I would write

for (var i = 0; i < foo.length; i += 1) {}

as

var fooIndex;
for (fooIndex = foo.length -1 ; fooIndex + 1 ; fooIndex -= 1) {
//Loop Content even if only a one liner.
}

I never declare vars in loops, or in the setup of a loop.

--- In jslint_com@yahoogroups.com, "pauanyu" <pcxunlimited@...> wrote:
>
>
>
> What about this (very) common construct:
>
> for (var i = 0; i < foo.length; i += 1) {}
>
> I agree that very short identifiers are generally a bad idea, but I also think
there are a couple exceptions (like the above).
>
> --- In jslint_com@yahoogroups.com, "abyssoft@" <abyssoft@> wrote:
> >
> > Reasoning
> >
> > Identifiers of only 1 or 2 Characters can lead to errors in thought and poor
readability of code. I have a preference for identifiers that consist of 3 or
more characters and they are rarely that short.
> >
> > An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
> >
>




[Non-text portions of this message have been removed]

As long as it's an optional switch, I'm fine with that. I can see why that would
help some people, especially in a team.

--- In jslint_com@yahoogroups.com, "abyssoft@..." <abyssoft@...> wrote:
>
> That is why I would like it as a switch/option not a requirement.
>
> I would write
>
> for (var i = 0; i < foo.length; i += 1) {}
>
> as
>
> var fooIndex;
> for (fooIndex = foo.length -1 ; fooIndex + 1 ; fooIndex -= 1) {
>     //Loop Content even if only a one liner.
> }
>
> I never declare vars in loops, or in the setup of a loop.
>
> --- In jslint_com@yahoogroups.com, "pauanyu" <pcxunlimited@> wrote:
> >
> >
> >
> > What about this (very) common construct:
> >
> > for (var i = 0; i < foo.length; i += 1) {}
> >
> > I agree that very short identifiers are generally a bad idea, but I also
think there are a couple exceptions (like the above).
> >
> > --- In jslint_com@yahoogroups.com, "abyssoft@" <abyssoft@> wrote:
> > >
> > > Reasoning
> > >
> > > Identifiers of only 1 or 2 Characters can lead to errors in thought and
poor readability of code. I have a preference for identifiers that consist of 3
or more characters and they are rarely that short.
> > >
> > > An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
> > >
> >
>

I do not see the value in a minimal length requirement for identifiers even if
that requirement is optional.  What problems does this actually prevent?  JSLint
already catches undeclared variables and so forth regardless of the length of
such.  Really, what this looks like to me an abstract arbitrary name replaced by
a longer name that is just as much abstract and arbitrary.  In my opinion this
fix merely sounds like an attempt to make code for reader friendly, which is a
false expectation from such a requirement as expanding length by no means
implies the longer length identifier is any more relevant a name.

Austin Cheney
http://prettydiff.com/

Austin,

Your reply looked rather vitriolic to my eyes. If it is optional why such
disdain?

For me I have found that with short identifiers in a long procedure I am quite
prone to accidental reuse of them in a manner that introduces bugs. By forcing
myself to use longer identifiers I can also be more assured that I have not left
in debug code, as that is the only time I would wish to use short identifiers.
Under the use of these conditions I would find it of great benefit.

As for abstract arbitrary names length, and casing can help. Personally I always
attempt to make it as clear as possible the purpose of the identifier in it
name. On the rare occasion this proves difficult I make sure to add
documentation.

For me personally it is exceedingly annoying to encounter code that has nothing
but 1 to 2 char identifiers and no or poor documentation. I always wish to leave
code in a better designed and documented state then when I first encountered it
so that those who come after me, including myself at a later point, have an
easier time modifying/correcting/adding.

--- In jslint_com@yahoogroups.com, "Cheney, Edward A SSG RES USAR USARC"
<austin.cheney@...> wrote:
>
> I do not see the value in a minimal length requirement for identifiers even if
that requirement is optional.  What problems does this actually prevent?  JSLint
already catches undeclared variables and so forth regardless of the length of
such.  Really, what this looks like to me an abstract arbitrary name replaced by
a longer name that is just as much abstract and arbitrary.  In my opinion this
fix merely sounds like an attempt to make code for reader friendly, which is a
false expectation from such a requirement as expanding length by no means
implies the longer length identifier is any more relevant a name.
>
> Austin Cheney
> http://prettydiff.com/
>

Austin may be vitriolic, but he has a point.

Code Complete by Steve McConnell is my bible and it has some interesting
things to say on single-character identifiers.

Personally, I only ever use single-character vars in short loops. For a
single iterator, I tend to use "n" (which betrays my beginnings in an
early BASIC); and I would generally eschew i, j, k for nested loops
unless there's a very good reason - i and j are so easy to confuse due
to "confirmation bias".

x & y (and z) are a special case also - these are handy for short loop
iterations when co-ordinate systems are in use.

Where speed isn't paramount, I've found a short object can be very
helpful. Using X and Y as an example, let's say I need two versions of
each, I might create two literal, local objects like this:

var old = {};
var cur = {};

and initialise some variables

old.x = 0;
old.y = 0;
cur.x = old.x +10;
cur.y = old.x +10;

Any operations could conceivably use "with" on these but that has
problems all of its own. Personally I never use it.

This is far clearer than using very long names, is very easy to type and
less error prone because we're grouping related variables. Of course,
your mileage may vary.

Sure James.  Cut and paste from our standards document:

All arguments to a function have a master prefix, 'arg_'.

Prefixes for compound variable types

prefix
variable type (vtype)
obj_ full object with methods
hash_ object as associative array
ary_ array
elem[type]_ dom element object; type is optional

$
  jquery object


Prefixes for scalar variable type
prefix
scalar type (stype)
count_ Integer counter
idx_ Integer loop or array index
idint_ Integer interval id
idto_ Integer timout id
int_
  Integer, general

ms_ Integer millisecond
num_
  floating point number, general

px_ Integer pixel units
str_ string, general

sw_ boolean switch (true or false)
Examples:

A single scalar might be px_screen_x.

If the variable is compound then the prefixes should be strung together, e.g.
ary_px_screen or hash_px_screen.

var fnRenderScreen = function ( arg_hash_px_screen ){...};

If a function takes multiple named arguments, we use a single input hash called
arg_hash_spec, e.g:

var fnRenderScreen = function ( arg_hash_spec ){...};

called like so:

ret = fnRenderScreen({ sw_overlay : true, px_left : 10, px_top: 250, px_width:
150, px_height: 150 });

Hope that helps :)

Cheers, Mike




________________________________
From: James Friedman <james.william.friedman@...>
To: z_mikowski@...
Sent: Mon, July 5, 2010 3:40:50 AM
Subject: Re: [jslint] Re: Enhancement Request: Identifier length restriction

Hello Mike,


I am interested in the prefixes that you use.  I find the use of
prefixes to be invaluable in keeping track of what-is-what - But then
I do often suffer from "Teflon of the brain - nothing sticks..."


Thank you,

-  James

On Mon, Jul 5, 2010 at 12:53 AM, Michael Mikowski <z_mikowski@...> wrote:
>
>
>
> Hi All:
>
> On a bit of a tangent, there are no sigils in javascript, so therefore we use
RPN to indicate data types. So my implementation would look something like this:
>
> var
> ary_foo = [ 'bing','bang','boom'],
> idx_foo
> ;
>
> for ( idx_foo = 0; idx_foo < ary_foo.length; idx_foo++ ){ }
>
> We have a comprehensive list of prefixes we currently use, if anyone is
interested.
>
> Feedback and suggestions are welcome :)
>
> Cheers, Mike
>
> ________________________________
> From: "abyssoft@..." <abyssoft@...>
> To: jslint_com@yahoogroups.com
> Sent: Sun, July 4, 2010 3:11:36 PM
> Subject: [jslint] Re: Enhancement Request: Identifier length restriction
>
> That is why I would like it as a switch/option not a requirement.
>
> I would write
>
> for (var i = 0; i < foo.length; i += 1) {}
>
> as
>
> var fooIndex;
> for (fooIndex = foo.length -1 ; fooIndex + 1 ; fooIndex -= 1) {
> //Loop Content even if only a one liner.
> }
>
> I never declare vars in loops, or in the setup of a loop.
>
> --- In jslint_com@yahoogroups.com, "pauanyu" <pcxunlimited@...> wrote:
> >
> >
> >
> > What about this (very) common construct:
> >
> > for (var i = 0; i < foo.length; i += 1) {}
> >
> > I agree that very short identifiers are generally a bad idea, but I also
think there are a couple exceptions (like the above).
> >
> > --- In jslint_com@yahoogroups.com, "abyssoft@" <abyssoft@> wrote:
> > >
> > > Reasoning
> > >
> > > Identifiers of only 1 or 2 Characters can lead to errors in thought and
poor readability of code. I have a preference for identifiers that consist of 3
or more characters and they are rarely that short.
> > >
> > > An alternate enhancement is for support of single and double letter
identifiers when listed in /*global*/.
> > >
> >
>
> [Non-text portions of this message have been removed]
>
>


--
--------------------------
Television and the media culture have replaced thoughtfulness with
entertainment.  We are being converted from a critically minded
inquisitive population enjoying informed discourse to a nation of
passive retards.


[Non-text portions of this message have been removed]

> For me personally it is exceedingly annoying to encounter code that
> has nothing but 1 to 2 char identifiers and no or poor documentation.

Beautify the code using a JSLint white space compatible algorithm.  Then
perform the following replacements:

For functions:
    - Manually change the name of the function where it is declared
    - Find and replace on the following after ensure that each of the
      following is not in quotes:
       + space + variable name + left paren
         ex: " a("
       + space + variable name + comma
         ex: " a,"
       + space + variable name + right paren
         ex: " a)"
       + space + variable name + right square brace
         ex: " a]"
       + space + variable name + right curly brace
         ex: " a}"

For arrays:
    - Same as above except find and replace on a left square brace
      instead of opening paren

For object literals
    - Same as above except find and replace on a left curly brace instead
      of opening paren

For value literals (strings and numbers)
    - Same as above except find and replace on a space, instead of an
      opening paren

You could write a JS application to do all of this for you.  This would
be the best bet because you are not going to influence how other people
write code their own code.  The only code that you can effectively
influence is the code under your own responsibility.

Austin Cheney
http://prettydiff.com/

Folks,

I am new to JSLint but have used JavaScript in several web pages I have created.
I am working my way through the JSLint error messages, correcting my code,
learning how to set the options and trying to make my JavaScript code better.

I get lot of messages about 'document.write' because I use it frequently. I
would like to understand
1) Why does JSLint object to 'document.write'?
2) What should I do to fix my code?

Example 1 of dozens of similar messages:

Problem at line 15 character 5: document.write can be a form of eval.

document.write(nbr+" is nbr<br />"); //absolute value

Steven G.

--- In jslint_com@yahoogroups.com, "stevengrindle2002" <stevengrindle2002@...>
wrote:
>
> Folks,
>
> I am new to JSLint but have used JavaScript in several web pages I have
created. I am working my way through the JSLint error messages, correcting my
code, learning how to set the options and trying to make my JavaScript code
better.
>
> I get lot of messages about 'document.write' because I use it frequently. I
would like to understand
> 1) Why does JSLint object to 'document.write'?
> 2) What should I do to fix my code?
>
> Example 1 of dozens of similar messages:
>
> Problem at line 15 character 5: document.write can be a form of eval.
>
> document.write(nbr+" is nbr<br />"); //absolute value
>
> Steven G.
>
document.write can be a form of eval.
From Crockford's JSlint instructions:
eval is evil
The eval function (and its relatives, Function, setTimeout, and setInterval)
provide access to the JavaScript compiler. This is sometimes necessary, but in
most cases it indicates the presence of extremely bad coding. The eval function
is the most misused feature of JavaScript.

The eval method takes a string containing JScript code, compiles it and runs it,
but the computing cost-effectiveness of starting an interpreter to compile it
outweighs other far more lightweight methods that achieve exactly what you want.

Try obtaining a reference to the desired element where you want to place your
text or HTML, and drop your code in with the easy non-standard way:
elementReference.innerHTML = nbr+" is nbr<br />" or the standards way
elementReference.appendTextNode(nbr+" is
nbr").appendChild(document.createElement("br"));

document.write() is evil because it affects the document as it's been
rendered. There are some (very,very few) instances when you might need
to do this.

I have used it recently to change a form on the client side depending on
whether or not Javascript was active, like so:

<script type="text/javascript">
      document.writeln("<input id='contactFormSend' disabled='disabled'
value='Send Request' type='submit' />");
</script>

<noscript>
<input value="Send Request" type="submit" />
</noscript>

This isn't something that can easily be done on the server and allows
the receiving code to see if Javascript was active when the form was
sent - at least, when the page was loaded. The server uses this to
determine the likelihood that the form has had minimal validation or
none at all and warn the user.

Using document.write or document.writeln as a debugging measure is
asking for trouble. Until recently (hang my head in shame) I relied on
Alert() or some concoction of DIVs. <shudders>

A far better solution is Firefox with the Firebug extension. Firebug can
write to a special console area:

console.log(var1, var2, object, ...);

and is very, very good at it too. You can even examine events objects
(for example) just by passing them like this:

function eventHandler(e)
{
      console.log(e);
      //...
}

Firebug allows you to decompose the entire event, method by property in
the console window which can be very handy indeed.

document.write is essential when executing JavaScript where a DOM is not
available, such as all possible methods of interpretation outside for a webpage
in a conforming user-agent.  Other than those conditions I don't see why this
method should ever be used.

Austin Cheney
http://prettydiff.com/

I'm trying to clean up some code with JSLint, but I have been running
into a problem with JSLint stopping prematurely when it comes across the
Comma Operator
<https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operator\
s/Special_Operators/Comma_Operator> .  Here is a simple example:

a = (1, 2);
alert(a);  // a = 2

JSLint first throws an error with the message "Problem at line 1
character 7: Expected ')' to match '(' from line 1 and instead saw ','."
And then it will stop saying that it is unable to continue.

It would be nice if JSLint could recognize the Comma Operator and
display a warning message because the Comma Operator is definately not
one of Javascript's good parts.  Unfortunately, GWT uses them a lot.



[Non-text portions of this message have been removed]

You are misusing the comma operator.  Commas in JavaScript exist to separate
items in a list.  Any other use of commas is invalid.

Valid uses of commas:
var a, b, c = 1, d = 2, e;
var myArray = [a, b, c];

Your example is invalid, because it is an attempt to assign two single value
data types to a single variable.  Your example would be valid if you replaced
the parenthesis with square brackets as then you would be assigning a list of
values to an array.  Your example would also be valid if you removed all but one
value/variable and all commas.  Aside from those two alternatives there is no
other way to make your example valid.

The logical implication of your example appears to be a tertiary operation,
which is assigning an "if" condition to a variable.  Here is an example:

var a, test = (a) ? 1:5;

In that example the variable "a" is tested for an assignment.  If "a" is
assigned a value "test" receives a value of 1 otherwise "test" receives a value
of 5.

The JSLint error reporting might possibly be more complicated than necessary
considering the simplicity of your example, but it is not wrong.

Austin Cheney
http://prettydiff.com/

Please see answer for question #4 from a popular JavaScript quiz:

http://www.nczonline.net/blog/2010/02/23/answering-soshnikovs-quiz/

Marcel

On Sat, Jul 17, 2010 at 8:58 PM, Cheney, Edward A SSG RES USAR USARC <
austin.cheney@...> wrote:

>
>
> You are misusing the comma operator. Commas in JavaScript exist to separate
> items in a list. Any other use of commas is invalid.
>
> Valid uses of commas:
> var a, b, c = 1, d = 2, e;
> var myArray = [a, b, c];
>
> Your example is invalid, because it is an attempt to assign two single
> value data types to a single variable. Your example would be valid if you
> replaced the parenthesis with square brackets as then you would be assigning
> a list of values to an array. Your example would also be valid if you
> removed all but one value/variable and all commas. Aside from those two
> alternatives there is no other way to make your example valid.
>
> The logical implication of your example appears to be a tertiary operation,
> which is assigning an "if" condition to a variable. Here is an example:
>
> var a, test = (a) ? 1:5;
>
> In that example the variable "a" is tested for an assignment. If "a" is
> assigned a value "test" receives a value of 1 otherwise "test" receives a
> value of 5.
>
> The JSLint error reporting might possibly be more complicated than
> necessary considering the simplicity of your example, but it is not wrong.
>
> Austin Cheney
> http://prettydiff.com/
>
>



--
Marcel Duran


[Non-text portions of this message have been removed]

I think you are missing the point:

"It would be nice if JSLint could recognize the Comma Operator and
display a warning message because the Comma Operator is definately not
one of Javascript's good parts. Unfortunately, GWT uses them a lot."

What they are asking is that JSLint output a warning about using the comma
operator, NOT that JSLint accept the comma operator as good code.

In other words, rather than giving vague warnings that aren't specific to the
problem, they want JSLint to specifically say "don't use the comma operator".

--- In jslint_com@yahoogroups.com, "Cheney, Edward A SSG RES USAR USARC"
<austin.cheney@...> wrote:
>
> You are misusing the comma operator.  Commas in JavaScript exist to separate
items in a list.  Any other use of commas is invalid.
>
> Valid uses of commas:
> var a, b, c = 1, d = 2, e;
> var myArray = [a, b, c];
>
> Your example is invalid, because it is an attempt to assign two single value
data types to a single variable.  Your example would be valid if you replaced
the parenthesis with square brackets as then you would be assigning a list of
values to an array.  Your example would also be valid if you removed all but one
value/variable and all commas.  Aside from those two alternatives there is no
other way to make your example valid.
>
> The logical implication of your example appears to be a tertiary operation,
which is assigning an "if" condition to a variable.  Here is an example:
>
> var a, test = (a) ? 1:5;
>
> In that example the variable "a" is tested for an assignment.  If "a" is
assigned a value "test" receives a value of 1 otherwise "test" receives a value
of 5.
>
> The JSLint error reporting might possibly be more complicated than necessary
considering the simplicity of your example, but it is not wrong.
>
> Austin Cheney
> http://prettydiff.com/
>

I'm trying to understand the rationale behind three of the "Good
Parts" options and haven't quite figured them out from the short
descriptions on the web site. Can someone give me a brief explanation
for why turning these options on is a good idea? I'm not looking to
debate them. I just want to understand the issues they avoid.

nomen
regexp
strict

--
R. Mark Volkmann
Object Computing, Inc.

Hi,

I thought it can be intresting
for those who don't have WSH (for example, I have Linux - there is no WSH) and
do not want to install Java and Rhino, but want to use jslint in console.

There is Perl module jslint, which have jslint cli version, wrapped in
perl and using spidermonkey library. However, this module consist
outdated version of JSLint library and seems broken.

I found easy way to run JSLint from cli using smjs tool from spidermonkey
package and small code:


var source=[];
var line;

while((line=readline())){
    source.push(line);
}

if(!JSLINT(source)){
    for(var i in JSLINT.errors){
        if(JSLINT.errors[i]) {
            print(i+') L:'+(JSLINT.errors[i].line+1)+'
C:'+(JSLINT.errors[i].character+1)+' ['+JSLINT.errors[i].reason+'] >
'+JSLINT.errors[i].evidence);
        }
    }
}

It can be used by 'smjs jslint.js < some.js'

> I found easy way to run JSLint from cli using smjs tool from
> spidermonkey package and small code

FWIW, a while back I wrote a simple Python wrapper to invoke JSLint:
      http://pypi.python.org/pypi/jslint

The main advantage, to me, is that it provides a report using standard
error format, so it can easily be used it within editors like Vim.


-- F.

Interesting. Standard format is very good, but I don't like extra dependence
(Python).

You could use NodeJS.  Should be a lot faster too.

http://github.com/reid/node-jslint


On Mon, Jul 19, 2010 at 7:00 AM, roltar@... <mr.roltar@...>wrote:

>
>
> Interesting. Standard format is very good, but I don't like extra
> dependence (Python).
>
>
>


[Non-text portions of this message have been removed]

On Mon, Jul 19, 2010 at 11:13 AM, roltar@... <mr.roltar@...>wrote:

> Hi,
>
> I thought it can be intresting
> for those who don't have WSH (for example, I have Linux - there is no WSH)
> and do not want to install Java and Rhino, but want to use jslint in
> console.
>
> There is Perl module jslint, which have jslint cli version, wrapped in
> perl and using spidermonkey library. However, this module consist
> outdated version of JSLint library and seems broken.
>
>
Sorry about that.  It's my
module<http://search.cpan.org/%7Ehdm/JavaScript-JSLint-0.06/>,
and I haven't figured out why it's breaking so badly.  I must come back and
pick it up again sometime.

In the meantime, there is also
jslint4java<http://code.google.com/p/jslint4java/>,
which comes with a command line version.

-Dom


[Non-text portions of this message have been removed]

nomen: Some developers use a _ to mean "hidden" or "private" properties, but
they are not actually hidden at all. They are visible just like all others. If
you really want it to be hidden, use a local variable with a closure.

regexp: The rationale behind this is that some people don't understand what .
and [^...] mean in regular expressions, so it causes their code to either accept
something as valid when it isn't, or reject something that's valid.

strict: "use strict" turns on ECMAScript 5's strict mode. This fixes numerous
flaws in JavaScript, and also causes some bad stuff to throw an error, rather
than failing silently. I think it's definitely a good thing to use this whenever
you can.

--- In jslint_com@yahoogroups.com, Mark Volkmann <r.mark.volkmann@...> wrote:
>
> I'm trying to understand the rationale behind three of the "Good
> Parts" options and haven't quite figured them out from the short
> descriptions on the web site. Can someone give me a brief explanation
> for why turning these options on is a good idea? I'm not looking to
> debate them. I just want to understand the issues they avoid.
>
> nomen
> regexp
> strict
>
> --
> R. Mark Volkmann
> Object Computing, Inc.
>

Thank you very much! That's exactly the kind of explanation I was hoping
for.

I have to say it's a little scary to thing about people writing regular
expressions and not knowing what "dot" means!

On Mon, Jul 19, 2010 at 12:40 PM, pauanyu <pcxunlimited@...> wrote:

>
>
> nomen: Some developers use a _ to mean "hidden" or "private" properties,
> but they are not actually hidden at all. They are visible just like all
> others. If you really want it to be hidden, use a local variable with a
> closure.
>
> regexp: The rationale behind this is that some people don't understand what
> . and [^...] mean in regular expressions, so it causes their code to either
> accept something as valid when it isn't, or reject something that's valid.
>
> strict: "use strict" turns on ECMAScript 5's strict mode. This fixes
> numerous flaws in JavaScript, and also causes some bad stuff to throw an
> error, rather than failing silently. I think it's definitely a good thing to
> use this whenever you can.
>
>
> --- In jslint_com@yahoogroups.com <jslint_com%40yahoogroups.com>, Mark
> Volkmann <r.mark.volkmann@...> wrote:
> >
> > I'm trying to understand the rationale behind three of the "Good
> > Parts" options and haven't quite figured them out from the short
> > descriptions on the web site. Can someone give me a brief explanation
> > for why turning these options on is a good idea? I'm not looking to
> > debate them. I just want to understand the issues they avoid.
> >
> > nomen
> > regexp
> > strict
> >
> > --
> > R. Mark Volkmann
> > Object Computing, Inc.
> >
>
>
>



--
R. Mark Volkmann
Object Computing, Inc.


[Non-text portions of this message have been removed]

P.S. ECMAScript 5 actually isn't supported in browsers right now, so the JSLint
option is more about future-proofing your code.

That way, when browsers finally do support ECMAScript 5, your code will reap the
benefits of strict mode.

Some benefits of ECMAScript 5 strict mode:

typeof [] returns "array" rather than "object"
typeof null returns "null" rather than "object"

If you forget to use "new" when using a constructor, like new Foobar(), it will
throw an error. Before, it would silently attach the constructor's properties to
the global object (usually window).

Dangling commas are allowed in object literals now. For instance, like this:

{
     foo: "hello",
     bar: "world",
}

There are no more implied global variables. You must now define variables using
the "var" keyword. Before, if you tried to assign to a variable that didn't
exist, it would implicitly create a global variable.

The special "this" variable correctly propagates within inner functions. For
instance, this code will run correctly:

var foo = {
     message: "Hello world",
     saySomething: function () {
         return (function () {
             return this.message;
         }());
     }
};

foo.saySomething() returns "Hello world". In previous ECMAScript versions, it
would return "undefined", because the meaning of "this" is bound to the global
object while within inner functions.

--- In jslint_com@yahoogroups.com, Mark Volkmann <r.mark.volkmann@...> wrote:
>
> Thank you very much! That's exactly the kind of explanation I was hoping
> for.
>
> I have to say it's a little scary to thing about people writing regular
> expressions and not knowing what "dot" means!
>
> On Mon, Jul 19, 2010 at 12:40 PM, pauanyu <pcxunlimited@...> wrote:
>
> >
> >
> > nomen: Some developers use a _ to mean "hidden" or "private" properties,
> > but they are not actually hidden at all. They are visible just like all
> > others. If you really want it to be hidden, use a local variable with a
> > closure.
> >
> > regexp: The rationale behind this is that some people don't understand what
> > . and [^...] mean in regular expressions, so it causes their code to either
> > accept something as valid when it isn't, or reject something that's valid.
> >
> > strict: "use strict" turns on ECMAScript 5's strict mode. This fixes
> > numerous flaws in JavaScript, and also causes some bad stuff to throw an
> > error, rather than failing silently. I think it's definitely a good thing to
> > use this whenever you can.
> >
> >
> > --- In jslint_com@yahoogroups.com <jslint_com%40yahoogroups.com>, Mark
> > Volkmann <r.mark.volkmann@> wrote:
> > >
> > > I'm trying to understand the rationale behind three of the "Good
> > > Parts" options and haven't quite figured them out from the short
> > > descriptions on the web site. Can someone give me a brief explanation
> > > for why turning these options on is a good idea? I'm not looking to
> > > debate them. I just want to understand the issues they avoid.
> > >
> > > nomen
> > > regexp
> > > strict
> > >
> > > --
> > > R. Mark Volkmann
> > > Object Computing, Inc.
> > >
> >
> >
> >
>
>
>
> --
> R. Mark Volkmann
> Object Computing, Inc.
>
>
> [Non-text portions of this message have been removed]
>

Also, I noticed that JSLint does not throw any warning at all for the Comma
Operator in the MDC example:

for (var i=0, j=9; i <= 9; i++, j--)
   document.writeln("a["+i+"]["+j+"]= " + a[i][j]);

Is that a mistake, or is this an acceptable use of commas?



--- In jslint_com@yahoogroups.com, "urangatang@..." <urangatang@...> wrote:
>
> I'm trying to clean up some code with JSLint, but I have been running
> into a problem with JSLint stopping prematurely when it comes across the
> Comma Operator
>
<https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operator\s/Speci\
al_Operators/Comma_Operator> .
> Here is a simple example: