别让函数把你绕晕:JavaScript 函数、参数与箭头函数实战指南
函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。

先把这篇的边界说清楚。站里已经有不少 JavaScript 基础指南:数组方法讲过怎么摆弄列表,字符串方法讲过怎么处理文字,数字与 Math 讲过怎么算账,正则讲过模式怎么配,解构、class 与原型链、闭包、事件循环、模块、Fetch、DOM、localStorage 也都各有一篇。这篇不讲它们,只讲一件事:函数本身。写网页时你每天都在调函数,点单页算总价是一个函数,点“加入购物车”跑起来的是一段函数,连数组的 map 和页面的 addEventListener 接的都是函数。下面用到的“青石咖啡馆”还是那个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具。之前几篇讲的是它的点单页怎么写样式、怎么摆布局、怎么算账,这回讲的是它的点单页怎么把重复的活包成函数:算一份订单多少钱、把菜名拼成一句话、按下按钮后刷新一次页面。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于函数的语法与行为,都来自 MDN 的《Functions — reusable blocks of code》《Arrow function expressions》《Rest parameters》三篇官方文档,来源见每篇的 meta 信息与 evidence 记录。读完这篇,你应该能做到四件事:分清函数声明与函数表达式、会给函数写参数和默认值、会用剩余参数与展开语法、知道箭头函数什么时候能用、什么时候会把 this 弄丢。这篇不讲生成器函数,不讲装饰器,也不展开讲 this 的全部规则,只在第九步讲清楚箭头函数与 this 的那一条线。
第一步:函数就是一段可以反复调用的代码
MDN 的 Learn 文章开篇先讲了一个让新手松口气的事实:函数你早就用过了,只是之前没点破。只要你在代码里写了一个名字,后面跟一对圆括号,而且它不是 for 循环、while 循环或者 if 判断这样的语言结构,你就是在用函数。改字符串的 replace 是函数,拼数组的 join 是函数,取随机数的 Math.random 也是函数。函数分两种:浏览器自带的叫内置函数,写在你自己代码里的叫自定义函数。内置函数有的甚至没法用 JavaScript 写出来,它们背后是浏览器用 C++ 这类系统语言写的底层代码。自定义函数是你自己起名字、自己写逻辑的,比如 MDN 文章里的例子:一个画 100 个随机圆圈的 draw 函数,和一个返回 0 到指定数字之间随机整数的 random 函数。random 函数只有三行:function random(number),里面 return Math.floor(Math.random() * number)。它存在的原因很实在:浏览器自带的 Math.random 只给 0 到 1 之间的小数,你要的是 0 到 100 之间的整数,所以自己包一层。函数的好处就这一句:一段代码只写一次,想用多少次就调用多少次。定义函数只是把它写下来,不调用就不会跑;调用的方法就是写出函数名再加一对圆括号,比如 draw()。咖啡馆点单页里,算订单总价就是这样一个函数:写一次 calcTotal,菜单变了、数量变了、折扣变了,调用它就行,不用把加法在页面上抄十遍。函数里面还可以调用别的函数,draw 里面就调用了三次 random。记住这一节的判断:看到名字加圆括号,先问一句这是定义还是调用,定义是把活包起来,调用是让活真的跑起来。
第二步:声明与表达式,提升只帮一半
写函数有两种基本写法,新手最容易混的就是它们在“提前调用”这件事上的区别。第一种是函数声明:function myFunction(),里面写 alert("hello")。MDN 明确写了,这种写法会被提升,也就是说你可以在定义它的那一行之前调用它,代码照样能跑。提升的意思是,JavaScript 在真正执行之前,先把函数声明收了起来,所以写在后面的定义,写在前面的调用也能找到它。第二种是函数表达式:把一个没有名字的函数,也就是匿名函数,交给一个变量,比如 const greet = function () { alert("hello"); }。MDN 同样明确写了,这种写法不会被提升,在它出现之前调用它会报错。匿名函数本身没有名字,常见于“一个函数要收另一个函数当参数”的场合,比如 addEventListener 的第二个参数就是传一个函数进去。两种写法没有绝对的好坏,但选哪种要心里有数:页面一加载就要用的工具函数,用声明写,放在文件下面也没事,调用方不用操心顺序;只在某个地方用一次的回调,用表达式或者箭头函数写,写在哪里就用在哪里。咖啡馆点单页里,算总价、格式化金额这种全页通用的工具,用函数声明写在文件底部,页面顶部的按钮逻辑随时调用它都行;点“加入购物车”时要跑的那一小段逻辑,用匿名函数直接写进 addEventListener 里,不用单独起名字。这一节的检查方法很简单:如果你在定义之前调用一个函数没报错,那它一定是声明;如果报错说它还没定义,那它就是表达式。提升只帮声明,不帮表达式,别把两种写法的好处混到一起指望。
第三步:参数与实参,名字对上才能干活
有的函数调用时不用给任何东西,比如 Math.random(),括号里空着就行;有的函数非得给点东西才能干活,比如 replace 要给“找什么”和“换成什么”两个值。MDN 在这里把两个词分得很清,日常说话可以混用,写代码时不能含糊:参数是写在函数定义里的变量名,实参是调用时真正传进去的值。function random(number) 里面的 number 是参数,调用时写 random(100),100 就是实参。多个参数或者多个实参之间用逗号隔开,顺序就是它们的对应关系,第一个实参对应第一个参数,第二个对应第二个,写错顺序,结果就全错。咖啡馆点单页里,算总价的函数要是写成 calcTotal(price, count),调用时就得按先单价、后数量的顺序写 calcTotal(1990, 2),写成 calcTotal(2, 1990) 就会把数量当成单价算,账单直接翻十倍。还有两个新手常踩的点:第一,少传实参不会报错,缺的那个参数在函数里就是 undefined,拿 undefined 去做加法,结果是 NaN,账单会悄悄变成 NaN;第二,多传实参也不会报错,多余的那个会被直接忽略,函数只看自己声明了几个参数。MDN 的例子也印证了这一点:数组的 join 方法参数是可选的,不传就用逗号当默认分隔符,传一个空格就按空格拼。这一节的判断很简单:每次调用函数,先数一数实参的个数,再对一对参数的顺序,个数和顺序都对上,函数才可能算对;个数不对,先看是不是该用下一节的默认值,或者第五节的剩余参数。
第四步:默认参数,少传也能跑
有些参数不是每次都非传不可,MDN 给的办法是在参数后面写一个等号再加一个默认值。文章里的例子很干净:function hello(name = "Chris"),里面打印 Hello 加上名字。调用 hello("Ari") 得到 Hello Ari,调用 hello() 不传任何东西,得到 Hello Chris,默认值顶了上来。默认值只在两种情况下生效:调用时根本没传那个实参,或者传的是 undefined。传了别的任何值,哪怕是空字符串或者 0,默认值都不会生效,函数就用你传的值。这条规则要记牢:空字符串是“我传了一个空名字”,undefined 是“我没传名字”,两者完全不一样。默认值还可以写成表达式,比如用前一个参数算出来,或者调另一个函数算出来,但新手先记住最简单的写法就够了。咖啡馆点单页里,默认参数最实用的地方是“可选的配置”:显示金额的函数 formatPrice(cents, symbol = "¥"),平时调用 formatPrice(3980) 就显示 ¥39.80,想换符号时再传第二个参数;算折扣的函数 applyDiscount(total, rate = 0.9),不传折扣率就默认九折。默认值还有一个配套习惯:把它放在参数列表的后面,必填的参数放前面,可选的放后面。这样调用时只传前几个就能跑,不用为了跳过中间某个参数去数逗号。这一节的检查方法:写完一个带默认值的函数,立刻用“不传那个参数”调用一次,看结果是不是默认值;再用“传 undefined”调用一次,看结果是不是一样;两个都对,这个默认值才算写对了。
第五步:剩余参数,把多余的收进一个数组
参数个数不固定怎么办?比如点单页要算一桌所有人的分摊,有时候 2 个人,有时候 8 个人,函数定义时根本不知道会传几个数。MDN 的 Rest parameters 参考页给的答案就是剩余参数:在最后一个参数前面写三个点,比如 function sum(...theArgs),调用时多传的实参会全部被收进一个真正的数组。文章里的例子验算过:sum(1, 2, 3) 得到 6,sum(1, 2, 3, 4) 得到 10,因为 theArgs 分别是 [1, 2, 3] 和 [1, 2, 3, 4],循环加起来就是答案。剩余参数有四条硬规矩,违反任何一条都是语法错误:一个函数只能有一个剩余参数;它必须是最后一个参数;它后面不能再写逗号;它不能有默认值。MDN 还给了 myFun 的例子:function myFun(a, b, ...manyMoreArgs),调用 myFun("one", "two", "three", "four", "five", "six"),a 是 "one",b 是 "two",manyMoreArgs 是 ["three", "four", "five", "six"]。只传两个实参时,manyMoreArgs 是空数组 [],不是 undefined;只传一个时,b 是 undefined,manyMoreArgs 还是 []。剩余参数是真正的数组,所以数组的方法都能直接用:MDN 的 multiply 例子是 function multiply(multiplier, ...theArgs),里面 return theArgs.map((element) => multiplier * element),调用 multiply(2, 15, 25, 42) 得到 [30, 50, 84],验算过,2 乘 15 是 30,2 乘 25 是 50,2 乘 42 是 84。还有 sortRestArgs 的例子:function sortRestArgs(...theArgs),里面 return theArgs.sort(),调用 sortRestArgs(5, 3, 7, 1) 得到 [1, 3, 5, 7]。这就是剩余参数相对老办法 arguments 的最大好处:arguments 不是真正的数组,调 sort 会直接抛错,剩余参数是数组,sort、map、forEach、pop 都能直接用。咖啡馆点单页里,剩余参数最适合“个数不定的同类东西”:calcTableTotal(...prices),不管一桌点了 3 道菜还是 8 道菜,全部收进数组再求和;写日志的 logOrder(...notes),想记几条记几条。这一节的判断:参数个数固定用普通参数,个数不定用剩余参数,老代码里的 arguments 能不用就不用。
第六步:展开语法,反方向把数组拆开传
剩余参数是把多个实参收进一个数组,展开语法正好反过来:把一个数组拆开,变成多个实参传进去。写法用的是同一个三个点,比如 Math.max(...scores)。MDN 的 Rest parameters 参考页在末尾链接了 Spread syntax 的参考页,展开语法与剩余参数是同一符号的两个方向,这篇按这个对照来写,展开语法的完整参考页没有单独列入三篇亲读来源,见 evidence 说明。道理本身很直观:一个函数只收一个个单独的参数,不收数组,你手里正好只有一个数组,这时候就用展开语法把它拆开。验算过的例子:scores 是 [12, 45, 7, 33],Math.max(...scores) 得到 45,和 Math.max(12, 45, 7, 33) 完全一样;如果直接写 Math.max(scores),传进去的是一个数组,得到的是 NaN,因为 Math.max 不认识数组。展开语法还能用在数组字面量里拼数组:const all = [...hot, ...cold],把热菜数组和冷菜数组拼成一个完整菜单;也能用在函数调用里传多个数组:sum(...a, ...b)。咖啡馆点单页里,展开语法最常见的两个地方:第一,取最高价、最低价时,Math.max(...prices) 和 Math.min(...prices),不用自己写循环比大小;第二,合并两份列表时,比如今日特价和常规菜单拼成一张全菜单。容易搞混的一点是方向:函数定义时写 ...theArgs 是“收”,函数调用时写 ...scores 是“拆”,同一个符号,写在定义里和写在调用里意思正好相反。这一节的检查方法:调用前先问一句,这个函数要的是一个个的值,还是一整个数组?要一个个的值,手里是数组,就用展开语法拆开;要一整个数组,手里是一个个的值,定义时就用剩余参数收起来。两个方向都写对,参数就再也不会传错地方。
第七步:返回值,没写 return,拿到的就是 undefined
函数算完东西,要把结果交出来,靠的就是 return。MDN 的 Learn 文章里,random 函数的最后一行是 return Math.floor(Math.random() * number),调用 random(100) 拿到的是一个 0 到 99 之间的整数,这个值就是 return 后面的表达式。return 有两条规矩:第一,函数执行到 return 就会立刻停下来,后面的代码一行都不会跑;第二,没写 return 的函数,调用它拿到的永远是 undefined。undefined 不是报错,是 JavaScript 在告诉你“这个函数没有交回任何东西”。这条规矩在点单页里最容易坑人:写一个算总价的函数,里面把价格加起来了,但忘了写 return,调用方拿到的就是 undefined,再拿 undefined 去显示金额,页面上就会出现 undefined 或者 NaN。反过来,只负责“做事”不负责“交结果”的函数,不写 return 是正常的,比如点按钮后往页面上加一行字的函数,它的任务是改页面,不是算出一个值,调用它本来就不需要拿回什么。return 也可以只写一个值,一次只能交回一个结果;想交回多个值,就把它们包进一个对象或者数组里再 return,比如 return { total: 3980, count: 2 },调用方再从对象里取。箭头函数有一条省写规则和 return 直接相关:只有一行表达式时可以省略大括号和 return,值会自动交回,下一节会细讲。这一节的判断很简单:写完一个函数,先问一句调用方要不要拿回一个值,要,就必须写 return;不要,就接受它返回 undefined。调用之后立刻把结果打印出来看一眼,是最便宜的检查办法。
第八步:箭头函数,三条省写规则
箭头函数是写匿名函数时更短的写法,MDN 的 Arrow function expressions 参考页把它从传统匿名函数一步步拆到最短,每一步都是合法的写法。起点是 function (a) { return a + 100; },第一步去掉 function 这个词,在参数和大括号之间放一个箭头,变成 (a) => { return a + 100; };第二步去掉大括号和 return,变成 (a) => a + 100,返回值自动交回;第三步只有一个参数时连括号也能去掉,变成 a => a + 100。三条省写规则要逐条记清:括号只有在“只有一个简单参数”时才能省,多个参数、没有参数、有默认值、有解构或者有剩余参数时,括号必须留着;大括号只有在“函数体就是一行直接返回的表达式”时才能省,函数体里有多条语句,大括号就必须留着,返回值也要用 return 显式写出来;箭头函数没有名字,想让它能被调用,要把它交给一个变量,比如 const add = (a, b) => a + b,或者直接把它传给另一个函数当回调。MDN 的例子验算过:materials 是 ["Hydrogen", "Helium", "Lithium", "Beryllium"],materials.map((material) => material.length) 得到 [8, 6, 7, 9],因为四个单词的长度分别是 8、6、7、9。还有对象字面量的坑:想让箭头函数直接返回一个对象,不能写 () => { foo: 1 },这样写大括号会被当成函数体,foo 会被当成标签,调用得到的是 undefined;正确写法是把对象包进圆括号,() => ({ foo: 1 })。咖啡馆点单页里,箭头函数最适合写短回调:菜单数组 map 成价格数组,写成 menu.map((item) => item.price);订单数组 filter 出未上菜的,写成 orders.filter((order) => order.status === "waiting")。这一节的判断:函数体只有一行就用表达式体,超过一行就用块体加 return,别为了省两行把可读性省掉。
第九步:箭头函数的 this,它没有自己的 this
箭头函数和普通函数最大的区别不在长短,而在 this。MDN 的 Arrow function expressions 参考页开宗明义:箭头函数只能用在非方法函数上,因为它们没有自己的 this。普通函数里的 this 是调用时才定的,谁调用它,this 就是谁;箭头函数里的 this 是定义时就定死的,它用的是外面那一层作用域的 this,调用方式改不了它。MDN 的例子很能说明问题:一个对象 obj 里有 i 等于 10,b 是箭头函数,c 是普通方法。调用 obj.b(),打印出来的是 undefined 和全局对象;调用 obj.c(),打印出来的是 10 和这个对象本身。因为箭头函数 b 里面的 this 不是 obj,而是定义 b 的时候外面的 this。配套的后果有三条:第一,call、apply、bind 对箭头函数没用。MDN 验算过:普通函数 add 用 call 传 obj 进去,100 加 1 加 2 加 3 得到 106;箭头函数 add 用 call 传同一个 obj,得到的是 48,因为它用的还是全局的 num 等于 42,42 加 1 加 2 加 3 就是 48,bind 也一样改不了它。第二,箭头函数不能当构造函数,new 一个箭头函数会直接抛错,提示它不是构造函数,它也没有 prototype 属性。第三,箭头函数没有自己的 arguments 对象,里面写 arguments 指的是外面那层函数的 arguments,想收不定个数的参数,MDN 明确建议用剩余参数代替:function foo(n),里面写 const f = (...args) => args[0] + n,调用 foo(1) 得到 11,因为 args[0] 是 10,10 加 1 是 11。也有反过来用箭头函数救场的时候:MDN 的 setTimeout 例子里,普通函数当回调时 this 会丢到全局,count 加出来是 NaN;换成箭头函数,this 留在外面的方法里,count 从 10 变成 11,打印 11。还有 class 字段里写箭头函数,this 会牢牢指向实例,解构出来单独调用也不会丢,MDN 把这种写法叫自动绑定的方法,但也提醒每个实例都会多建一个函数,内存会多花一点。咖啡馆点单页的规矩应该是:写对象的方法、写构造函数、需要用 this 指对象本身的地方,用普通函数;写短回调、写 setTimeout 里的小逻辑、想留住外面的 this 时,用箭头函数。这一节的判断:写箭头函数之前先问一句,这里面的 this 该是谁?答不上来就别用箭头函数写方法。
第十步:函数当参数传,回调与高阶函数
函数在 JavaScript 里可以像数字、字符串一样被传来传去:当作参数传给另一个函数,或者当作返回值交回来。收了别的函数当参数的函数,就叫高阶函数。MDN 的 Learn 文章里最直接的例子是 addEventListener:textBox.addEventListener("keydown", logKey),第一个参数是事件名 "keydown",第二个参数就是函数 logKey。浏览器在用户按下键的时候调用 logKey,并且把一个包含按键信息的 event 对象传进去。也可以不单独定义 logKey,直接把匿名函数写进调用里:textBox.addEventListener("keydown", function (event) { console.log(`You pressed "${event.key}".`); }),再改成箭头函数就是 (event) => { console.log(`You pressed "${event.key}".`); }。数组方法是最常见的回调场合:MDN 的 Arrow function expressions 参考页验算过,arr 是 [5, 6, 13, 0, 1, 18, 23],arr.reduce((a, b) => a + b) 得到 66,5 加 6 加 13 加 0 加 1 加 18 加 23 正好是 66;arr.filter((v) => v % 2 === 0) 得到 [6, 0, 18],数组里只有这三个偶数;arr.map((v) => v * 2) 得到 [10, 12, 26, 0, 2, 36, 46],每个数乘 2 验算都对得上。新手在这里最容易踩的坑,是把“传函数”和“调函数”搞混:addEventListener("click", handleClick) 是把函数本身传进去,等点击发生时浏览器再调用它;写成 addEventListener("click", handleClick()),括号一加,函数在注册的那一刻就立刻跑完了,传进去的是它返回的 undefined,点击时什么都不会发生。咖啡馆点单页里,回调无处不在:点“加入购物车”传一个函数,输入框内容变化传一个函数,数组 map、filter、reduce 每一个都传一个函数。判断回调写没写对,有一个便宜的办法:看括号。传函数时名字后面没有括号,调函数时才有括号;回调里想传参数,包一层箭头函数再调,比如 () => addItem("latte"),而不是直接写 addItem("latte")。这一节的结论:函数当参数传,传的是“以后再跑的活”,不是“现在就跑的结果”。
第十一步:作用域,函数里的变量外面看不见
函数不光是包代码的工具,也是锁变量的盒子。MDN 的 Learn 文章讲作用域时打了一个公寓楼的比方:每间公寓是私人的,相当于函数作用域,函数里定义的变量和函数只有函数里面的代码能碰到,外面的代码碰不到;楼里的游泳池、健身房是公共的,相当于全局作用域,全局定义的变量哪里都能用。文章里的例子很具体:全局定义了 x 等于 1,函数 a 里面定义了 y 等于 2,函数 b 里面定义了 z 等于 3,output 函数负责把值打印到页面上。在控制台调用 output(x),能打印出 1;调用 output(y) 或者 output(z),会直接抛错,提示 ReferenceError,说 y 或者 z 没有定义,因为 y 和 z 被锁在各自的函数里。反过来,在函数 a 里面调用 output(y),就能正常打印,因为调用和变量在同一个作用域里;在函数 a 里面调用 output(x),也能打印,因为 x 是全局的,哪里都能看见。还有一个配套的规矩:用 let 和 const 在 if 判断或者 for 循环的大括号里定义的变量,作用域也被锁在那对大括号里,外面同样看不见;用老式的 var 定义的变量就不一样,它会被提升到函数作用域甚至全局作用域,if 外面也能读到,这正是 MDN 建议只用 let 和 const 的原因之一。咖啡馆点单页里,作用域的规矩直接决定了变量名会不会打架:算总价的函数里用 total,算折扣的函数里也用 total,两个 total 各锁各的,互不干扰;但如果把 total 定义在全局,两个函数你改我也改,最后算出来的数是谁改的都说不清。这一节的检查方法:拿到 ReferenceError 说某个变量没有定义,先别急着补定义,看看这个变量是不是被锁在别的函数里;是的话,要么把值用参数传进去,要么用 return 交出来,别图省事把它改成全局变量。
第十二步:上线前检查清单与一张错因图
下面这张图是虚构的青石咖啡馆点单页一个月 100 次函数翻车的原因分布,数字是编的例子,用来对照前面十一步的坑:忘了写 return 19 次最多,箭头函数当方法用、this 丢了 17 次,参数顺序传错 15 次,剩余参数和展开语法写反方向 14 次,默认参数写在剩余参数后面 12 次,回调里多写了一对括号、函数提前跑了 11 次,匿名函数没名字、调试时找不到 7 次,函数声明和函数表达式的提升搞混 5 次,19 + 17 + 15 + 14 + 12 + 11 + 7 + 5 = 100,账平。
写完点单页的函数逻辑,上线前拿这七个问题自查一遍。第一,调用和定义分清了吗?名字加圆括号是调用,只写名字是传函数,回调里多一对括号,函数就提前跑了。第二,参数的个数和顺序对上了吗?少传会变成 undefined,多传会被忽略,顺序错了账单直接算错。第三,默认值生效的条件对吗?只有没传或者传了 undefined 时默认值才顶上,空字符串和 0 不会触发默认值。第四,剩余参数写在最后了吗?一个函数只能有一个剩余参数,它不能有默认值,后面也不能再写逗号。第五,箭头函数用对地方了吗?写方法、写构造函数、需要 this 指对象本身时用普通函数,写短回调、想留住外面的 this 时用箭头函数。第六,return 写了吗?调用方要拿回值就必须写 return,没写 return 拿到的就是 undefined。第七,变量的作用域查过了吗?函数里的变量外面看不见,拿到 ReferenceError 先查作用域,别急着改成全局变量。这七个问题查完,再回头看 MDN 的三篇文档:Learn 的那篇讲的是函数的基本概念和作用域,Arrow function expressions 参考页是箭头函数的完整说明书,Rest parameters 参考页是剩余参数的规则清单。三篇的分工不一样,查问题时别走错门:不知道某个写法允不允许,去对应的参考页;不知道函数整体该怎么组织,回 Learn 那篇。还有最后一句提醒:这篇没讲的生成器函数、异步函数里的箭头函数细节、装饰器,都有各自的坑,真要用时先去读对应的 MDN 文档,别凭印象写。
评论 (0)
原始来源
相关文章
JavaScript 里数字只有一种类型 Number,存成 64 位浮点数,所以 0.1 + 0.2 等于 0.30000000000000004。本文按 MDN 的《Basic math in JavaScript》《Math》《Number》三篇官方文档讲清楚:一种数字类型、浮点误差、钱改成分算、字符串转数字、NaN 与 Infinity、安全整数、四种取整、Math.random、Math 工具箱与显示格式化。
选择器是一条规则的第一部分,它决定样式落到谁身上。本文按 MDN 的《Basic CSS selectors》《Attribute selectors》《Pseudo-classes and pseudo-elements》三篇官方文档讲清楚:类型、类、ID、选择器列表、通配、属性选择器、伪类、伪元素,以及把它们链起来写,附一份样式没生效时的检查清单。
不用图片、不用图库:点单页的“本周点单量”柱状图和笑脸都是用 Canvas 现场画出来的。本文按 MDN 的 Canvas 教程《Basic usage》《Drawing shapes》《Applying styles and colors》讲清楚:默认 300×150、左上角原点、fillRect 与 strokeRect、beginPath-moveTo-lineTo-fill/stroke 路径套路、弧度制的圆弧、贝塞尔曲线、fillStyle 与 strokeStyle、透明、线条样式、渐变图案阴影,以及靠重画动起来。