三、具体语法

在比较两种编程语言时，必然会有结构和语法上的差异。 好消息是 Python 和 JavaScript 都是人类可读的语言，所以从 Python 到 JavaScript 和 Node.js 的上下文切换应该不会太费力。

样式是个好问题:制表符还是空格? 分号? Python 的 PEP-8 风格指南中包含了许多用任何编程语言编写时出现的风格问题。 虽然 JavaScript 并没有官方的风格指南，但不用担心——它并不是狂野的西部。

在编写 JavaScript 之前，我们必须知道它是什么，以便能够阅读和理解它。 所有编程语言都各不相同，使用 Python 知识学习一门新语言需要对思想进行一些重新构建。 例如，当我们想要声明变量时，JavaScript 是什么样子的? 它是如何构造的，使计算机能够理解它? 在我们进步的过程中，我们需要注意什么?

这一章是解开 JavaScript 能做什么以及如何做的关键。

本章将涵盖以下主题:

• 风格的历史
• 语法规则
• 标点符号和可读性
• 房间里的大象——空白
• 现有的标准-甄别来拯救!

技术要求

要编写本章中的示例代码，你有几个选择:

• 直接在浏览器的 JavaScript 控制台中编写代码
• Node 命令行中的代码
• 使用网络编辑器，如jsfiddle.net或codepen。 io

使用一个网络编辑器可能是更好的，因为你可以很容易地保存你的进度。 无论如何，您应该熟悉在浏览器中打开 JavaScript 控制台，因为我们将使用它来调试输出。 这通常在浏览器的“视图”菜单中; 如果不是很明显，请参考浏览器文档，了解如何找到它，因为有些浏览器需要在 Preferences 中打开 Developer 模式。

你可以在 GitHub 上的https://github.com/PacktPublishing/Hands-on-JavaScript-for-Python-Developers/tree/master/chapter-3/Linting找到本章的代码文件。

风格的历史

每种编程语言都有自己的风格，旨在简化每一行代码的易读和理解。 有些语言比其他语言更严格; JavaScript 的普通形式是一种松散的语言，它对风格的坚持。 Brian W. Kernighan 和 P. J. Plauger 合著的《编程风格的要素》(The Elements of Programming Style)于 1974 年首次出版，其中有许多格言不仅帮助形成了编码标准，也帮助形成了编程语言本身。

您可能对thethe Zen of Python中的 PEP-20 格言很熟悉:

• 美丽胜于丑陋。
• 明确比含蓄好。
• 简单比复杂好。
• 复杂胜于复杂。
• 扁平比嵌套好。
• 稀疏比密集好。
• 可读性。
• 特殊的情况不会特别到违反规则。
• 尽管实用性胜过纯粹性。
• 错误不应该无声地过去。
• 除非显式地沉默。
• 面对模棱两可，拒绝猜测的诱惑。
• 应该有一种——最好是唯一一种显而易见的方法来做到这一点。
• 虽然这种方式可能一开始并不明显，除非你是荷兰人。
• 现在做总比不做强。
• 正确现在。
• 如果实现很难解释，那就不是一个好主意。
• 如果实现很容易解释，那么这可能是个好主意。
• 名称空间是一个非常棒的想法——让我们多做一些这样的事情吧!

抛开这些半开玩笑的特点不谈，这些格言中的许多都是受到 Python 开发之前编写的原则和获得的经验的启发。 Python 于 1991 年首次发布，从一开始就强调代码的可读性，并有一些严格的指导原则，从 PEP-8 到 PEP-20。

让我们以两条格言为例:

| The Elements of Programming Style, 1974 | The Zen of Python, 1999 | | 写得清楚些——不要太聪明。 | 明确比含蓄好。 |

这里也表达了类似的观点。 我想大多数软件工程师都会同意这样的说法:清晰、明确和易读是开发程序时应该追求的良好品质。

记住强烈有一个主意,然而,正如你在 JavaScript 继续推进学习:自 JavaScript 语法是宽松的设计比其他一些语言,你会发现不同的公司内部风格使用 JavaScript 代码。 这并不是 javascript 所独有的——许多语言在公司中也有风格指南，以加强员工之间的代码一致性。 它还有助于语言的更大生态系统拥有一致可读的代码。 然而，这确实会导致代码库在风格上的差异。

*对于任何语言，我们都需要知道语法，才能知道如何编写 JavaScript。 与 Python 一样，机器在工作之前需要正确格式化的代码，这是您的工作。 语法。

语法规则

就像其他编程语言一样，JavaScript 也有语法规则，要遵循这些规则，计算机才能理解我们的代码试图告诉它的内容。 这些规则相当简单，范围从提高可读性的代码的大写和标点，到在代码中使用特定的结构，以及避免使用可能混淆意思的常见单词。 JavaScript 语法规则相当简单明了; 它们包括:

• 资本化
• 保留字
• 变量的语法
• 数据类型
• 逻辑结构
• 功能
• 标点符号

资本项

和大多数编程语言一样，大小写也有区别。 myNode和mynode变量将被解释为完全不同的变量。 也就是说，计算机绝对会看到myNode和mynode之间的关系，因为它们的大写形式不同。

保留字

在 JavaScript 中有很多保留的单词不能用于变量名。 以下是其中大部分的清单:

| abstract【t16.1】arguments await boolean break 【5】 case catch 【显示】 class const continue 【病人】 default delete do | double【t16.1】else enum eval export 【5】 false final 【显示】 float for function 【病人】 if implements import | in【t16.1】instanceof int interface let 【5】 native new 【显示】 package private protected 【病人】 return short static | super【t16.1】switch synchronized this throw 【5】 transient true 【显示】 typeof var void 【病人】 while with yield |

这些词总是小写的，如果您试图使用其中一个词作为变量名，程序将显示一个错误。

声明变量

在 JavaScript 中，最好的做法是在使用变量之前声明它们。 这种声明可以发生在赋值时，也可以定义一个没有值的变量。

不像其他语言，JavaScript 是松散类型，所以你不需要声明你创建的变量的类型。 按照惯例，JavaScript 中的变量以小写字母开头，并遵循驼峰式大小写，而不是蛇形大小写。 因此，myAge优于my_age或MyAge。 变量不能以数字开头。

JavaScript 中有三个关键字用来声明变量:const、let、var。

常量

const是constant的缩写，是一个在程序运行过程中不会发生值变化的变量。 它们对于强制执行您不想更改的值很有用。 在 ECMAScript 的第六版 ES2015(通常称为 ES6)之前，可以改变任何变量的值，所以常见的错误是使用赋值操作符(=)而不是比较操作符(==或===):

const firstName = "Jean-Luc"
const lastName = "Picard"

当然，皮卡德船长可以改变他的名字，但那似乎不太可能。

有时，我们希望将变量声明为硬常量，如 pi 或 API 键。 一般来说，这些用例是命名标准的唯一例外，因为它们通常都是大写，有时还有下划线:

const PI = 3.14159
const API_KEY = 'cnview8773jass'

到目前为止，我们有两个数据类型的例子:字符串和数字。 JavaScript 没有floatversusintversuslong的概念; 他们都是数字。 如果你注意到，我们也可以用单引号或双引号声明字符串。 有些库和框架偏爱其中一种，但对于标准 JavaScript 来说，两者都可以使用。 然而，最好的做法是在使用中保持一致。

让

当使用let声明一个变量时，我们显式地声明期望或允许该变量的值在程序过程中发生变化:

let ship = "Stargazer"
ship = "Enterprise" // ship now equals "Enterprise"

皮卡德船长可以在任何时候被转移到另一艘船上，所以我们希望我们的程序允许值的变化。

var

在 JavaScript 中定义变量最古老的方法是使用var关键字。 用var声明变量不会对变量的值施加任何限制; 它是可以改变的。

The use of var is still supported but considered legacy and was deprecated in ES6. However, with decades of existing programs and examples, it's important to at least be familiar with var.

数据类型

即使 JavaScript 是松散类型的，了解可用的数据类型也是很重要的，因为我们需要了解这些数据类型来处理比较和重新分配等问题。

下面是基本 python 变量到基本 JavaScript 的粗略映射:

| Python | JavaScript | | 数量 | 数量 | | 字符串 | 字符串 | | 列表 | 数组 | | 字典 | 对象 | | 集 | 集 |

这涵盖了您可能使用的基本类型。 让我们看看其他更细微的 JavaScript 数据类型。 有些在 Python 中有等价的，有些没有:

| Python | JavaScript 半等效 | 差异原因 | | bool | boolean | 虽然数据类型在实践中是相同的，但 Python 的bool数据类型继承自int。 虽然1和0可以在 JavaScript 中表示True和False，但它们不会被识别为boolean类型。 | | None | null | 从技术上讲，None本身是一个对象，而null是一个伪值。 | | | undefined | 在 JavaScript 中，没有声明值的变量仍然有一个伪值:undefined值的单例。 | | | object | Python 和 JavaScript 都是面向对象的语言，但它们对对象的使用略有不同。 JavaScript 中对象的基本用法是键值存储。 对象不是原语，可以存储多种类型的数据。 | | | symbol | 符号是 ES6 中的一种新的数据类型。 虽然使用是微妙的，但还是值得一提。 它们用于为对象创建惟一标识符。 |

现在，在使用类型之前，我们需要了解更多关于类型的信息，包括如何比较它们并使用它们。

typeof 与平等

尽管变量类型是可变的，但了解变量的数据类型通常是很有用的。 typeof操作符帮助我们做到这一点:

typeof(1) // returns "number"
typeof("hello") // returns "string"

注意，返回值是字符串。

比较变量时，有两种相等操作符:松散相等和严格相等。 让我们来看一些例子:

let myAge = 38
const age = "38"
myAge == age

如果我们运行这个比较，我们会得到true的结果。 但是，我们可以看到，myAge是一个数字，而age是一个字符串。 其结果为true的原因是，当使用松散相等操作符(双等于)时，JavaScript 使用类型强制，试图提供帮助。 在比较不同类型的变量时，比较值是松散的，所以38和"38"是不同的类型，但比较结果是真实的，因为它们的值不同。

可以想象，这会产生一些意想不到的行为。 要要求 JavaScript 在比较中包含该类型，请使用严格相等操作符:the triple-equals。

在前面的例子中，我们可以尝试myAge === age并得到false的结果，因为它们是不同的数据类型。 通常认为使用严格相等是最佳实践，以避免类型强制，除非您有特定的需要使用松散相等。

数组和对象

数组和对象不是原语，可以包含混合类型。 以下是一些例子:

const officers = ['Riker','Data','Worf']

const captain = {
  "name": "Jean-Luc Picard",
  "age": 62,
  "serialNumber": "SP 937-215",
  "command": "NCC 1701-D",
  "seniorStaff": officers
}

officers是一个数组，如方括号所示。 关于数组的一个有趣的事实是，尽管我们通常将它们声明为 const，但数组中的值是可以改变的。 .push()和.pop()是操作数组的两个有用方法:

officers.push('Troi') // officers now equals ['Riker','Data','Worf', 'Troi']

注意数组中的值没有按任何方式排序; 我们可以通过访问括号标记为officers[0]的数组得到Riker。 然而，如果试图完全重新分配数组，在重新分配已声明的 const 对象时仍然会得到错误。 数组可以保存任何数据类型的组合。

我们将使用的数组的一个非常方便的属性是.length。 因为它是一个属性，所以它不使用括号:

officers.length // now equals 4

注意，即使数组是零索引的，length属性不是。 数组中有四个元素，的索引为，从 0 到 3。

我们将在本章中更多地讨论方法和属性。

对象是 JavaScript 的一个非常强大的基础组件。 事实上，从技术上讲，JavaScript中的一切都是对象! 我们的数组方法可以通过点符号来访问，这是因为数组在技术上是一种对象类型。 然而，我们不能使用点表示法访问数组的值。

如果我们看一下captain，我们可以看到三种不同的数据类型:字符串、数字和数组。 对象也可以有嵌套的对象。 作为键值存储功能的一部分，键应该是一个字符串。 要访问一个值，我们使用点表示法:

captain.command // equals "NCC 1701-D"

我们可以使用点表示法访问对象的部分，这类似于 Python 中的dict，但并不完全如此! 当我们处理对象时，这些细微差别将变得更加清晰，因为它们是使 JavaScript 独一无二的基础。

条件

让我们看一下用 Python 和 JavaScript 两种方式编写的if/else语句:

| Python | JavaScript | |

if a < b:
  min = a
else:
  min = b

|

let min

if (a < b) {
  min = a
} else {
  min = b
}

min = a if a < b else b

|

let min = (a < b) ? a : b

|

在这两列中，代码做的是相同的事情:一个简单的测试，看看a是否小于b，然后将较小的值赋给min变量。 第一行是完整的if/else语句，第二行使用三元结构。 在这些例子中有一些语法规则需要注意:

• min必须在使用前声明，作为最佳实践。 在严格模式下，这实际上会抛出一个错误。
• 我们的if子句是用括号封装的。
• 我们的if/else语句是用花括号封装的。
• 与 Python 相比，三元中的关键字和操作符有很大的不同(而且更加神秘)。

如果我们想使用我们现在所知道的typeof，我们可以使用严格相等来更多地理解我们的变量:

let myVar = 2

if (typeof(myVar) === "number") {
  myVar++; // myVar now equals 3
}

循环

在 JavaScript 中有四种主要类型的循环:for、while、do/while和for..in。 (还有其他一些方法来构造循环，但这些是主要的方法。) 他们的用例不应该太令人惊讶。

for 循环

使用迭代器执行指定次数的代码:

| Python | JavaScript | |

names = ["Alice","Bob","Carol"]
for x in names:
    print(x)

|

const names = ["Alice","Bob","Carol"]

for (let i = 0; i < names.length; i++) {
  console.log(names[i])
}

|

现在，你可能会想，“如果 JavaScript 有一个for..in循环，为什么我们不使用它?” 事实证明，Python 的for/in和 JavaScript 的for..in是错误的同源词:它们的名字看起来很像，但在使用上却截然不同。 我们稍后将讨论 JavaScript 的for..in循环。 另外，注意我们在for循环中需要三个子句:

Figure 3.1 - Declaration, Condition, and Execution stages of a for loop

声明将定义一个迭代器或使用现有的可变变量。 注意，它应该是一个可变的数字!

我们正在测试的是我们的条件。 我们希望当i小于names.length时循环运行。 由于name.length是3，我们将运行循环三次，或者直到i等于4，不再满足我们的条件。

在循环的每次迭代结束时，我们执行; 通常是对声明进行简单的递增。 现在，注意我们每个子句之间的分号……不像 JavaScript 的其他部分，这些是而不是可选的。 没有一个放在执行部分之后。

while 循环

JavaScript 的while循环在使用上与 python 中的等效循环相同，只是少了一点语法:

| Python | JavaScript | |

i = 0
while i < 10:
    i += 1

|

let i = 0
while (i < 10) {
   i++
}

|

做/ while 循环

顾名思义，当给定的条件等于true时，do/while循环执行do代码。 看看 JavaScript:

let i = 0

do {
  i++
} while (i < 10)

在循环. .

现在，我承诺解释为什么 Python 的for..in与 JavaScript 的用法不同。 不同之处在于，JavaScript 的for..in用于迭代对象中的键，而 Python 的for..in用作对离散实体集的循环。

让我们来看一个例子:

const officers = ['Riker','Data','Worf']

const captain = {
  "name": "Jean-Luc Picard",
  "age": 62,
  "serialNumber": "SP 937-215",
  "command": "NCC 1701-D",
  "seniorStaff": officers
}

let myString = ''

for (let x in captain) {
  myString += captain[x] + ' '
}

你认为myString现在等于什么? 因为在JavaScript中使用for..in的目的是检查对象中的键，所以它是Jean-Luc Picard 62 SP 937-215 NCC 1701-D Riker,Data,Worf。

循环的. .

还有一个for循环:for..of，与for..in不同。 for..of循环遍历任何可迭代对象的值，如数组、字符串、集合等。 如果我们想要遍历officers并注销每个名称，我们可以这样做:

for (const officer of officers) {
  console.log(officer)
}

接下来，我们将讨论函数!

功能

啊,功能。 我们喜欢他们，因为他们是模块化的关键，不要重复自己(DRY)程序。 JavaScript 和 Python 中的用例是相同的:需要多次调用的代码块，通常带有不同的参数。 参数是函数为了在可变数据集上执行其代码而使用的变量。 参数是调用函数时传递的参数。 它们本质上是相同的东西，但根据它们的使用地点和时间有不同的词:它们是抽象的，还是实际的数据? 让我们来看看并排比较:

| Python | JavaScript | |

def add_one(x):
  x += 1
  return x

print(add_one(5))
// output is 6

|

function addOne(val) {
  return ++val
}

console.log(addOne(5))
// output is 6

|

如果您还没有在浏览器中打开 JavaScript 控制台，那么现在应该打开它，以查看6的输出。

您可以看到结构非常相似，参数是在括号中传递的。 如前所述，我们更喜欢 JavaScript 中的驼峰大小写，并用花括号封装。 用参数5调用函数也是一样的。 为简洁起见，在执行return之前，可以使用左边的++操作符增加val。 这样的快捷方式在 JavaScript 中很常见，但要记住谨慎使用:“写得清楚——不要太聪明。”

然而，JavaScript 实际上有两种不同的方法来声明函数，加上 ES6 中引入的较新的语法。

函数声明

上面代码中的addOne()是一个函数声明的例子。 它使用 function 关键字来声明函数。 它的解剖结构和它看起来一样简单:

function functionName(optionalParameters, separatedByCommas) {
  // do work
  // optionally return a value
}

函数表达式

下面是一个addOne()的例子，构造为一个函数表达式:

const addOne = function(val) {
  return ++val
}

函数表达式应使用const，但使用var或let在语法上没有错误。

声明和表达式之间的区别是什么? 核心区别在于，函数声明可以在程序中的任何地方使用，因为它将提升到。 因为 JavaScript 是自上而下解释的; 这是该范式的一个主要例外。 因此，相反地，使用表达式必须出现在表达式写入之后。

箭头功能

ES6 引入了编写函数表达式的箭头语法:

const addOne = (val) => { return ++val }

更复杂的是，我们可以省略val周围的圆括号，因为只有一个参数:

const addOne = val => { return ++val }

箭头函数和表达式之间的主要区别集中在词法作用域。 我们讨论了提升的范围，我们将在下一章详细讨论。

评论

对于任何语言来说，注释都很重要。 在 JavaScript 中有两种声明注释的方法:

const addOne = (val) => { return ++val } // I am an inline, single line comment

// I am a single comment

/*
 I am a multiline comment
*/

因此，我们可以以//开始注释，并将文本写入该行尾。 我们可以用//注释全行，也可以用/*注释多行，以*/结尾。 此外，您可能会遇到 JSDoc 风格的注释，用于内联文档:

/**
 * Returns the argument incremented by one
 * @example
 * // returns 6
 * addOne(5);
 * @returns {Number} Returns the value of the argument incremented by one.
 */    

更多关于 JSDoc 的信息包含在进一步阅读部分。

方法和属性

到目前为止，我们已经看到了.push()和.pop()作为数组实例的方法。 在 JavaScript 中，方法只是其数据类型所固有的一个函数，它对变量的数据和属性进行操作。 我之前提到过，JavaScript 中的几乎所有东西都是对象，这一点也不夸张。 从功能、语法到结构和用法，对象的原始数据类型与任何其他变量之间都有许多相似之处。

我们理解 JavaScript 语法的下一部分是每个人都喜欢的:标点符号。 虽然它看起来微不足道，但它对于人类和计算机对代码的解释是非常重要的。

标点符号和可读性

和所有语言一样，JavaScript 在标点符号和空格如何影响可读性方面有约定。 让我们来看看一些想法:

• Python:

def add_one(x):
  x += 1
  return x

• Java:

int add_one(int val) {
  val += 1;
  return val;
}

• c++:

int add_one (int val)
{
  val += 1;
  return val;
}

• JavaScript:

function addOne(val) {
  return ++val
}

在 JavaScript 中，上述示例的约定如下:

• 函数名和括号之间不能有空格。
• 在同一行的花括号前有一个空格。
• 右花括号在自己的一行上，与function的开始语句对齐。

这里还有一个更现代的观点，关于 JavaScript 和我们将在这本书中使用的例子，以及你可能在现场和网上遇到的例子:分号。

除了少数例外，在现代 JavaScript 中，语句结尾的分号是可选。 在过去，总是用分号结束语句行是一种最佳实践，您将在现有代码中看到许多分号。 这是一个从公司到公司、从项目到项目、从图书馆到图书馆的风格问题。 现在已经有了一些标准，稍后我们将讨论检测，但出于本书的目的，我们将而不是使用分号来终止语句，除非在语法要求的情况下(如我们在循环中看到的)。

同样重要的是，嵌套的行应该缩进两个空格。 二对四也是一个风格问题，但在这本书中，我们将使用两个空格。 一种有助于保持一致性的方法是配置代码编辑器，将制表符转换为两个空格(或四个，根据需要)。 这样，你只需按键键，而不用担心你捣毁了多少次空格键。 我不会详细说明适当缩进的重要性，但请记住:你的代码越是遵循风格和最佳实践，它对那些维护代码的人来说就越清晰——对你未来的自己来说也越清晰!

房间里的大象——空白

好的，好的，我们知道 Python 是用空格分隔的:制表符很重要! 然而，JavaScript 实际上在大多数情况下并不关心空格。 正如我们之前看到的，缩进和空格是关于样式，而不是语法。

事情是这样的:当我第一次学习 Python 时，依赖空格的语言的想法是令人憎恶的。 我想，“一门与不适当的 IDE 设置相冲突的语言怎么能存活下来呢?” 抛开我的观点不谈，好消息是 Python 中的缩进与 JavaScript 中的缩进加花括号是并行的。

这里有一个例子:

| Python | JavaScript | |

def hello_world(x):
 if x > 3:
   x += 1
 else:
   x += 2
 return x

|

function helloWorld(val) {
  if (val > 3) {
    return ++val
  } else {
    return val+2
  }
}

|

如果你注意到，我们的 Python 函数中的if语句与这个 JavaScript 示例的缩进方式相同，只是没有花括号。 所以耶! 你对 python 缩进的坚持实际上在 JavaScript 中非常有用! 虽然它不需要包括空格à laPython，但它确实提高了可读性。

归根结底，JavaScript 和 Python 一样喜欢缩进，因为它使代码更具可读性，尽管它不是程序运行所必需的。

现有的标准-甄别来拯救!

我们已经了解了 JavaScript 的约定和规范，但大多数规则都有一个警告，即“这可能会有所不同”或“这不是技术要求”。 那么，我们如何在一个可塑的、由意见驱动的环境中理解我们的代码呢? 一种答案:打针。

简单地说，linting指的是通过预定义的规则运行代码的过程，以确保代码不仅语法正确，而且还遵循适当的样式规则。 这并不局限于 JavaScript; 您可能也检查了您的 Python 代码。 在现代 JavaScript 中，检测已被视为确保代码一致的最佳实践。 社区中主要的两种风格指南是 AirBnB(https://github.com/airbnb/javascript)和谷歌(https://google.github.io/styleguide/jsguide.html)。 您的代码编辑器可能支持使用 linter，但我们现在不会在实践中使用它们，因为每个编辑器在设置中都是不同的。 这里是一个快速看一下它在 Atom 中看起来像什么:

Figure 3.2 - Linting error in Atom

出于我们的目的，要知道标准确实存在，尽管它们可能因风格指南而不同。 你可以从https://github.com/PacktPublishing/Hands-on-JavaScript-for-Python-Developers/tree/master/chapter-3/Linting克隆一个演示 linting 的存储库。

有几个流行的检测工具可用，如 ESLint 和 Prettier。 您选择的工具可以根据您选择使用的样式指南进行定制。

好吧，这一章就够多了! 让我们结束。

总结

JavaScript 有丰富的语法和语法，经过多年的使用和改进。 使用 ES6，我们有一大堆数据类型、函数声明方法和代码标准。 虽然编写 JavaScript 似乎非常松散和快速，但它有最佳实践，而且该语言的基础与其他语言一样健壮。 记住大写很重要; 不要使用保留字作为变量名; 使用const或let声明变量; 即使 JavaScript 是松散类型的，数据类型也很重要; 条件、循环和函数都有助于构建代码的逻辑。

掌握 JavaScript 的语法和语法对于理解如何使用这种健壮的语言至关重要，所以请花些时间熟悉细节和复杂之处。 接下来，我们假设你对 JavaScript 的风格已经很熟悉了。

在下一章中，我们将接触数据并理解 JavaScript 如何处理和建模数据。

问题

试着回答下面的问题来测试一下你的知识:

1. 下面哪个选项不是有效的 JavaScript 变量声明?
   1. var myVar = 'hello';
   2. const myVar = "hello"
   3. String myVar = "hello";
   4. let myVar = "hello"

2. 哪一个开始函数声明?

   1. function
   2. const
   3. func
   4. def

3. 下面哪个不是基本循环类型?

   1. for..in
   2. for
   3. while
   4. map

4. True 或 false - JavaScript要求用分号分隔行。

   1. 真正的
   2. 假
5. 在 JavaScript 中空格从不计算。
   1. 真正的
   2. 假

进一步的阅读

• B. W. Kernighan 和 P. J. Plauger，编程风格的元素第二版，McGraw Hill，纽约，1978。 ISBN 0-07-034207-5
• PEP-8 -A Style Guide for Python Code:https://www.python.org/dev/peps/pep-0008/
• PEP-20 -The Zen of Python:https://www.python.org/dev/peps/pep-0020/
• http://usejsdoc.org/***

版权属于：月萌API www.moonapi.com，转载请注明出处

本文链接：https://moonapi.com/news/376.html