Javascript in Ten Minutes
Spencer Tipping
December22,2010
Contents
1Introduction3 2Types3 3Functions4
我心爱的宝贝
3.1Variadic behavior(a cool thing) (4)
3.2Lazy scoping(a cool thing) (4)为什么吃饺子
3.3The meaning of this(the egregious disaster) (5)
3.3.1Important conquence:eta-reduction (6)
4Gotchas7
4.1Semicolon inference (7)
4.2Void functions (7)
4.3var (8)
4.4Lazy scoping and mutability (8)
4.5Equality (9)
4.6Boxed vs.unboxed (9)
4.7Things that will silently fail or misbehave (10)
4.8Things that will loudly fail (11)
4.9Throwing things (11)
4.10Be careful with typeof (11)
4.11Also be careful with instanceof (12)
4.12Browr incompatibilities (13)
5Prototypes13
高原红歌曲原唱5.1Why new is awful (14)
5.2Why you should u prototypes (15)
5.3Autoboxing (15)
6A Really Awesome Equality15
1
7If You Have20Minutes (16)
7.1Forwarding constructors (17)
7.2Iterators for cool people (17)
7.3Java class and interfaces (18)
7.4Recursive metaclass (19)
7.5Tail calls and delimited continuations (20)
7.6Syntactic macros and operator overloading (22)
8Further reading24
2
1Introduction
This guide is for anyone who knows some Javascript but would like a quick1
intro to its advanced features.It will be easier reading if you also know another functional language such as Ruby,Perl,Python,ML,Scheme,etc,since I don’t
really explain howfirst-class functions work.
2Types
Javascript has nine types.They are:
1.Null–null.Chucks a wobbly if you ask it for any ull.foo
fails.Never boxed.2
2.Undefined–undefined.What you get if you ask an object for something
博物馆英语怎么说
it doesn’t istent.Also chucks a wobbly if you
ask it for any attributes.Never boxed.
3.Strings–e.g.’foo’,"foo"(single vs.double quotation marks makes no
difference).Sometimes boxed.Instance of String when boxed.
4.Numbers–e.g.5,3e+10(all numbers behave asfloats–significant for
division,but can be truncated by x>>>0).Sometimes boxed.Instance
脱贫攻坚故事of Number when boxed.
5.Booleans–true and fal.Sometimes boxed.Instance of Boolean when
boxed.
6.Arrays–e.g.[1,2,"foo",[3,4]].Always boxed.Instance of Array.
7.Objects–e.g.{foo:’bar’,bif:[1,2]},which are really just hashta-
bles.Always boxed.Instance of Object.
8.Regular expressions–e.g./foo\s*([bar]+)/.Always boxed.Instance
of RegExp.
9.Functions–e.g.function(x){return x+1}.Always boxed.In-
stance of Function.
理想和现实
The value null is actually almost never produced by Javascript.The only
ca you’re likely to run across null is if you assign it somewhere(most of the
time you’ll get undefined instead–one notable exception ElementById, which returns null if it can’tfind an element).Making sparing u of undefined
and instead using null can make bugs much easier to track down.
1Longer than ten minutes,despite what the title says.
2Boxing is just a way of saying whether something has a pointer.A boxed type is a reference
type,and an unboxed type is a value type.In Javascript,this has additional ramifications as well–
e ction4.6.
3
3Functions
Functions arefirst-class lexical closures,3just like lambda s in Ruby or sub s in
Perl.4They behave pretty much like you’d expect,but there are veral really
cool things about functions and one really egregious disaster.
3.1Variadic behavior(a cool thing)
Functions are always variadic.5Formal parameters are bound if they’re prent;
otherwi they’re undefined.For example:
(function(x,y){return x+y})(’foo’)//=>’fooundefined’The arguments to your function can be accesd in afirst-class way,too:
var f=function(){return arguments[0]+arguments[1]};
var g=function(){return arguments.length};
f(’foo’)//=>’fooundefined’
g(null,fal,undefined)//=>3
The arguments keyword is not an array!It just looks like one.In particular,
doing any of the will cau problems:
[1,2,3].concat(arguments)
arguments.push(’foo’)
arguments.shift()
To get an array from the arguments object,you can say Array.prototype.slice.call(arguments). As far as I know that’s the best way to go about it.
3.2Lazy scoping(a cool thing)
Internally,functions u a lexical scoping chain.However,the variables inside
a function body aren’t resolved until the function is called.This has some really
nice advantages,perhaps foremost among them lf-reference:
var f=function(){return f};
f()===f//=>true
3First-class in the n that you can pass them around as values at runtime.You can’t reliably
introspect them,however,becau while you can obtain their source code via toString you won’t
be able to access the values they clo over.
虎和牛属相合不合4Note that block scoping isn’t ud–the only scopes that get introduced are at function bound-
aries.
5The number of arguments a function accepts is referred to as its arity.So a unary function,
which is monadic,takes one,a binary function,which is dyadic,takes two,etc.A function that
takes any number of arguments is said to be variadic.
4
Tidbit of pathology:An important conquence of lazy scoping is
that you can create functions that refer to variables that might never
exist.This makes Javascript very difficult to debug.The good part
is that Javascript can be made to support syntactic macros via the
toString method:
var f=function(){return$0+$1};
var g=String().replace(/\$(\d+)/g,
function(_,digits){return’arguments[’+digits+’]’}));
g(5,6)//=>11(except on IE)
Theoretically by extending this principle one could implement true
structural macros,operator overloading,a type system,6or other
things.低值易耗品定义
3.3The meaning of this(the egregious disaster)
One would think it is a simple matter tofigure out what this is,but it’s apparently quite challenging,and Javascript makes it look nearly impossible.
Outside of functions(in the global scope,that is),the word this refers to the
global object,which is window in a browr.The real question is how it behaves
inside a function,and that is determined entirely by how the function is called.
Here’s how that works:
1.If the function is called foo(5),then inside that function’s body
the word this will be equivalent to the global object.
2.If the function is called as a foo(5),then inside that
function’s body the word this refers to the object,in this ca x.
3.If the function starts offas a method and then is called alone:
var f=x.foo;
f(5);
then this will be the global object again.Nothing is remembered about
where f came from;it is all determined right at the invocation site.
4.If the function is invoked using apply or call,then this points to what-
ever you t it to(unless you try to t it to null or undefined,in which
ca it will be the global object again):
var f=function(){return this};
f.call(4)//=>4
f.call(0)//=>0
f.call(fal)//=>fal
f.call(null)//=>[object global]
6God forbid.
5
