你可能想通过比较两个字符串从而知道在字母排列顺序上谁高谁低，或者仅仅想知道它们是否相等。

你可以用很多方式来解决这个问题，我将在本文中向你展示两种方法。

1. 如何使用 localeCompare 来比较字符串

你可以使用 localeCompare 的方法来比较当前环境（locale）下的两个字符串，以下是它们的语法：

string1.localeCompare(string2)

localeCompare 返回：

• 1 如果 string1（在字母排列顺序上）比 string2 大
• -1 如果 string1（在字母排列顺序上）比 string2 小
• 0 如果 string1 和 string2 在字母顺序上相等

下面是一些比较两个字符串的例子：

const string1 = "hello"
const string2 = "world"

const compareValue = string1.localeCompare(string2)
// -1

它返回了 -1 是因为在英语环境中，hello 中的 h 排在 world 中的 w 之前（ w 在字母顺序中比 h 更靠后）。

另一个例子：

const string1 = "banana"
const string2 = "back"

const compareValue = string1.localeCompare(string2)
// 1

上面的比较给出了 1，因为在英语环境中，banana的 ban 在 back 的 bac 之后。

再来一个例子：

const string1 = "fcc"
const string2 = "fcc"
const string3 = "Fcc"

const compareValue1 = string1.localeCompare(string2)
// 0

const compareValue2 = string1.localeCompare(string3)
// -1

比较 "fcc" 和 "fcc" 可以得到 0，因为它们在顺序上是相等的。"fcc" 和 "Fcc" 的结果是 -1，因为大写 "F" 大于小写 "f"。

在某些浏览器中，它可能会返回 -2/ 或其他一些负值，而不是 -1/。因此，不要依赖 -1 或 1，而是依赖负值（小于 0）或正值（大于 0）。

2. 如何使用数学运算符来比较字符串

在比较字符串时，你也可以使用数学运算符如大于（>）、小于（<）以及等于。

数学运算符的工作原理与 localeCompare 类似——根据字符串中字符的顺序返回结果。

使用之前的例子：

const string1 = "hello"
const string2 = "world"

console.log(string1 > string2)
// false

string1 不大于 string2，因为 h 在 w 之前，所以是小于。

对于另一个例子而言：

const string1 = "banana"
const string2 = "back"

console.log(string1 > string2)
// true

string1 比 string2 大，因为 ban 在 back 之后。

而对于最后一个例子：

const string1 = "fcc"
const string2 = "fcc"
const string3 = "Fcc"

console.log(string1 === string2)
// true

console.log(string1 < string3)
// false

string1 等于（===）string2，但是 string1 不小于 string3 ，这与localeCompare相反。

用数学运算符，"fcc" 大于 "Fcc"，但是用 localeCompare，"fcc".localeCompare("Fcc")" 返回 -1，表明 "fcc" 小于 "Fcc"。

这种处理是我不建议使用数学运算符来比较字符串的原因之一，尽管它有做到这一点的潜力。

我不推荐使用数学运算符的另一个原因是，"fcc" > "fcc" 和 "fcc" < "fcc" 是 false，但 "fcc" 等于 "fcc"。所以如果你依赖于数学运算符，得到 false 的原因可能与你相信的不同。

所以，对于比较字符串，在可能存在的许多方法中，使用 localCompare 是一个有效的方法，因为它可以用于不同的语言。

现在你知道了一个简单的比较字符串的方法。编码愉快：）

学习编程可能就像准备一场持久的战役，最终的胜利并不总是取决于你最初的能力，而是你准备得有多好以及你能坚持多长时间。

当学习编程的时候，最大的挑战往往不是语言的复杂度，而是保持步调并且在学习过程中获得动力。

为了在你的学习过程中保持步调，你将需要许多动力与精力，通过持续不断地学习将帮助你理解编程语言中复杂的概念，学编程可不能一口吃成个胖子。

因为我没有接触过任何技术性的东西，所以我开始学习编程较晚。在我尝试迈出转型第一步后，每一步的学习都十分地挣扎，我越来越怀疑自己的动机。

这篇文章我将分享我如何随着时间的累积逐渐克服困难，从而坚持下来并且自我激励。

放平心态，养成习惯

在早期学习阶段，你可能没有太多的时间用来学习。

这是因为你刚开始尝试做一些你从没有做过的事情，并且你可能有全职工作会占据你每日生活中大部分的时间，因此仅仅是挤出时间来学习就实属不易了。

在这个阶段，你并不需要担心你一口气能学多少，最重要的事情是抽出时间每天学，无论学了多少、无论发生什么情况，都要坚持下去！

始终为你的学习做好规划

如果你不管理好你的每日任务，你就十分容易拖延并且遗忘它们。你很容易专注于一两件任务上并且全然忘记你还有其他的任务要做，这种情况在你没有设置任务清单时会经常发生。

为了防止拖延及健忘，确保你通过制定任务来管理你的时间，你可以通过以下建议来制定你的任务：

1. 想想你总共有多少任务需要完成
2. 预估完成每项任务需要多少时间
3. 确定你一天什么时候最有生产力
4. 按优先级来安排好你所有的任务
5. 确保将相似的任务安排在一起从而提高效率
6. 在你的手机或电脑上排好任务以便管理
7. 将复杂及困难的任务安排在你脑子最好使的时候
8. 为意想不到的状况预留时间以防遭遇到它

值得一提的是最好是在每周开始的时候安排好一周的计划。

想了解更多关于如何安排你的时间以提高生产力，你可以考虑阅读这篇由 Calendar 的联合创始人及 CEO——John Rampton 所撰写的文章

参加一个学习者社区

对于绝大多数人而言，独自学习可能是孤独且乏味的，而且很快就会伤害你的学习积极性，拥有志同道合的朋友一块儿准没错。

这种类型的社区将带给你无数的好处，包括但不限于：

• 获得组团学习的机会
• 得到不同的资源来帮助你学习成长
• 获取当下的技术趋势讯息
• 给你的个人项目带来反馈
• 扩展一个能分享你的进展、衡量你的成长的渠道

寻找你所在的地区是否存在这类型的社区。如果你找不到，你也可以加入一个远程学习社区来代替。

下面是一些我发现的远程社区，我觉得他们非常有价值：

• 100Devs： 这个社区是一个非营利性组织，由 Leon Noel 维护——他是一名老师、以及 ResilientCoders 的技术主管。100Devs 社区向个人提供免费的全栈网络开发课程，你可以加入他们。
• 100DaysofCode： 这是一个 100 天学习编程语言的挑战。为了参加 100DaysofCode，你必须每天投入至少一小时的时间来学习，并且还需要在 Twitter 上发布你所完成的任务并且带上标签 #100DaysofCode。
• Kevin Powell Community： Kevin Powell 主动学习者社区是一个 Discord 频道由 Kevin Powell 创建并维护。Kevin 是一个拥有多年经验的教师以及软件开发人员，你可以从这儿加入。
• Commit Your Code： 这个社区由 Danny Thompson 创建，这个社区有很多主动学习者以及经验丰富的开发者，他们十分愿意帮助及指导你的项目。你可以从这儿加入该社区。

当然了 freeCodeCamp 社区也拥有一个充满支持与善意的论坛，你可以在这儿问问题并且遇到其他的开发者。

在加入其中的一个或多个社区后，重要的是拿出你最好的态度，也别忘记保持自我，提供价值、遵守规则。

寻找一个学习伙伴

如果你即便是管理好你的任务并且加入一个学习社区后，还是很难坚持下来并保持动力，在这种情况下，你可能需要一名学习伙伴。

拥有学习伙伴可以从以下几个方面受益：

• 能让你建立起责任感
• 可以设置共同学习的时段
• 可以在合作项目上协作
• 可能会互相得到指导
• 一起通过编程挑战

使用更高效的学习技巧

编程语言通常来说都比较复杂。除非你有一个高效的学习技能，否则你会很难理解其中的概念并且很难运用在实际的情况中，这会使你沮丧并且打击你学习的动力。

如果你在学习一些新的概念或者新的编程语言，这里有一些学习技巧可能你已经尝试过：

• 反复阅读
• 突出重点
• 总结或做笔记
• 填鸭式学习

但是很多著名的科学家及心理学家通过大量的证据证明——对比以下的学习技巧，以上的学习技巧效果较差。

为了最好的利用你的时间并确保你能更长时间地记住你所学的内容，请尝试以下的学习技巧：

主动回忆

主动回忆是一种学习技巧，指的是从你的大脑中检索已经储存的信息。

大脑是一个巨大的仓库或空间，记忆是储存在这个空间中的物体，检索记忆就像是在物理空间中搜寻和发现一个物体一样（Roediger，1980）。

使用这种技巧意味着曾经阅读过一个主题，然后将该主题中的概念和想法转换为问题，然后用问题来向自己提问。

间隔重复

这个学习技巧，顾名思义，需要通过主动回忆的方式，对你所学的知识进行间断性的复习。这与填鸭式的学习不同，填鸭式学习是指一次性记住这个主题的所有概念。

从本质上讲，间隔重复可以帮助你将遗忘曲线的影响最小化。这是一种允许自我忘记所学的学习方式，然后通过明确的时间、主动的回忆、从而从你的大脑中找回这些概念。

遗忘曲线假定了记忆的保持将会随着时间逐渐下降。这个曲线展现了当没有试图记忆信息时，信息是如何随着时间不断流逝而丢失。（Source）

使用上述学习技巧将帮助你确保你不会花费太多时间理解并记忆任何的主题或者概念。

并且，你将有更多的时间用于完成你清单上的其他任务，有机会学习对你的专业发展更有帮助的新技能。

你可以使用一个流行的工具——— Anki，来帮助你主动会议及间隔重复。学习如何使用 Anki。

要了解更多关于这些高效学习技巧的使用，可以观看这个视频。

番茄钟（Pomodoro Timer）

Pomodoro 学习技巧是那些挣扎于无法长时间集中注意力来学习的人的理想技巧。

使用这种技巧的一种方法是将你的工作时间分为 30 或者 20 分钟的小块，中间有 5 分钟的休息时间，这些间隔被称为 Pomodoros。

设置短期目标并保持专注于一次实现一个目标。

成功不会在一夜之间发生。

尝试在同一时间实现太多的目标会让人不知所措。所以最好是分解你的目标成为几个小目标，然后集中精力一次实现一个小目标。

例如，作为一个初学者，假定你的目标是能用任何流行的 JavaScript 框架建立一个网页。要做到这一点，你需要学习各种脚本、编程语言、工具和技能。下面是你实现目标所需要知道的：

1. 理解 HTML 的基础知识。
2. 理解 CSS 的基础知识。
3. 理解 HTML 中语义元素的使用。
4. 理解 CSS Flexbox 和网格布局的使用情况。
5. 尝试用你目前所学来建立一个简单的静态网站。
6. 开始学习 JavaScript 的基础知识。
7. 用你到目前为止学到的 HTML、CSS 和 JavaScript 的基础知识专注于建立项目。
8. 开始学习高级的 JavaScript 概念，如面向对象的编程和异步编程。
9. 通过建立项目来巩固你对高级概念的知识。
10. 学习你选择的JavaScript框架。React、Vue 和 Angular 都是流行的选择。
11. 最后，你可以使用你所学的框架建立你喜欢的项目。

你可能会认为，按照所述顺序完成上述步骤需要几个月的时间。也可能会花费更长时间，没事儿。

另外，不要试图跳过任何步骤，仅仅参加一个速成的网页设计课程可能是不够的，而且会让你感到失望，并导致你如果想要花时间彻底学习这些概念的时候，会更加挣扎。

另一方面，确保你仔细地通过每一个步骤，一次一个，将帮助你建立必要的技能来实现你的主要目标。这也会防止你失去动力，失去动力是不切实际的期望的结果。

不要害怕寻求帮助

人们在学习编程时过早放弃的原因之一是他们在程序中碰到了某种似乎难以解决的 Bug。

但是你应该知道在编程上，没有人知道所有的事情，即便是拥有几十年经验的软件开发人员仍然会遇到他们认为很难解决的 Bug。

这就是为什么合作是如此的重要的主要原因之一——甚至比发展你的个人技能更重要。

每当你发现自己处于这种状况时，不要在问题上徘徊太长时间。在寻找答案时要利用互联网的优势。在这一方面，你最好的朋友是 Google。如果你花时间并且深究，你可以在 Google 上得到几乎所有与编程相关的答案。

如果你无法从 Google 上搜索到你所需要的答案，下一步要做的就是去你所属的学习社区，从他人那里寻求帮助，他们通常都会十分愿意帮助你，无论问题是什么。

在向社区寻求帮助时需要注意以下几点：

• 直接提出问题
• 确保问题清晰易懂
• 提供一份你的代码副本，把它们放在一个公共的远程仓库里，如 GitHub 或 Codepen，并提供该仓库的链接。

保持健康的生活方式

我怎么强调保持健康生活方式的好处都不为过。它将帮助你维持精力充沛并保持健康，以迎接下一次挑战。

有各种方法来保持健康的生活方式，其中有些是：

• 经常锻炼有助于提高你的认知能力和身体素质。
• 不要长时间坐着。
• 在学习时定期锻炼手指。
• 学习时，眼睛要定期离开屏幕。
• 为你的兴趣爱好腾出时间，作为对你努力的奖励。
• 确保你总是睡得好，得到适当的休息。

总结

编程是一场马拉松，而不是一场短跑。如果你想取得任何程度的成功，你必须花时间并坚持不懈地学习。

采取本文所讨论的步骤将极大地提高你实现目标的机会。

如果你喜欢这篇文章，你可以给我一个 shout-out。

拓展阅读和参考资料

1. Retrieval creates learning
2. The forgetting curve
3. Download Anki, a powerful tool for active recall and spaced repetition

函数（function）是编程的基本概念之一。函数能让我们编写简洁的、模块化的、可多次使用的和可维护的代码，它还能帮助我们在编写代码时遵守 DRY 原则。

在本文中，你将了解 JavaScript 中有哪些函数，如何编写自己的自定义函数以及如何执行它。

作为先决条件，你应该熟悉一些基本的 JavaScript 概念，如变量（variable）、表达式（expression）和条件语句（conditional statement），以便理解本文。

什么是 JavaScript 中的函数？

函数是为了执行特定任务而编写的——可重复使用的代码块。

你可以将函数视为主程序（program）中的子程序。函数由一组语句组成，但作为单个单元执行。

在 JavaScript 中，我们有一些浏览器内置功能，如 alert()、 promp() 和 confirm()。你以前可能在你的项目中使用过这些吧？但你仍然可以创建你自己的自定义函数。

有几种方法可以定义函数。最常见的是函数声明（declaration）和函数表达式。

如何使用函数声明来定义函数？

你可以编写像这样的函数声明：

function nameOfFunction() {
	//这里是一些代码......
}

基本上，函数声明由以下内容组成：

• 函数关键字（keyword）
• 函数的名称
• 小括号（Parentheses）（可以包含参数，也可以为空）
• 函数主体（用大括号（curly braces）括起来）

这里有一个例子：

function sayHello() {
	console.log("Hello world"); 
}

该函数不会做任何事情——也就是输出（output） Hello world ，除非你调用（invoking）了这个函数。

调用该函数的方法如下：

sayHello();

//输出：Hello world

以下是另一个例子：

function sum(num1, num2){
	return num1 + num2;
}

要调用此函数，我们需要这样：

sum(1, 2);

//输出：3

你可以看到我们的第一个函数示例和第二个函数示例之间略有区别。

如果你猜到这是因为第二个函数小括号中的内容，恭喜你答对了！

当我们定义函数 sum() 时，它包含了两个形式参数（parameter） —— num1 和 num2。当我们调用这个函数时，我们传递了两个值（value）——实际参数（argument）1 和 2。

形式参数是你在声明函数时传递给函数的变量。

假设你希望你的函数是动态（dynamic）的，形式参数它就可以在不同的时间将函数的逻辑应用于不同的数据集。

这就是形式参数派上用场的地方，这样一来，你的函数就不会重复输出相同的结果。反过来说，它的结果是取决于你传入的数据。

另一方面，实际参数是相当于你调用函数时，传递给形式参数的值。

因此，声明一个带有形式参数的函数的语法将看起来像这样：

function nameOfFunction(parameters){
	//函数体......
}

然后再调用该函数：

nameOfFunction(arguments)

如何使用函数表达式来定义一个函数？

函数表达式是定义一个函数的另一种记法。就语法而言，它与函数声明类似。但是函数表达式允许你定义一个命名的函数，或者省略函数名来创建一个匿名（anonymous）函数。

让我们看看一个函数表达式是什么样子的：

let namedFunction = function myFunction(){
	//这里是一些代码......
}

注意，在这个例子中，函数有一个名字，myFunction。而匿名函数则不是这样的。当定义一个匿名函数时，你要省略函数名，就像下面这个例子：

let anonymousFunction = function(){
	//这里是一些代码......
}

你可以看到，这两个函数的例子都是分配给了一个变量的，没错吧？

一个函数关键字创建了一个函数值，当它被用作表达式时，可以分配给一个变量。

因此，为了调用这个函数，我们使用作为新函数名的变量名来调用它。

函数声明和函数表达式之间的一个主要区别是，对于函数声明，你甚至可以在定义函数之前就调用它。这在函数表达式中是不可能的。

比如说：

console.log(greeting());

function greeting(){
  console.log("Hope you're are good?");

}
//输出：Hope you're good?

如果函数被定义为一个函数表达式，这就不灵了，因为函数表达式遵循的是从上到下的控制流序列。

如何在JavaScript中使用箭头（arrow）函数？

箭头函数是函数表达式的另一种记法，但它们的语法更短。它是在ES6中引入的，可以帮助我们编写更简洁的代码。

在这里，函数关键字被排除在外，我们使用一个箭头符号（=>）来代替。语法看起来像这样：

let nameOfFunction = (parameters) => {
	//函数体
}

如果大括号内的函数主体只包含一条语句，那么大括号可以省略。带有大括号的箭头函数必须包括 return 这一个关键字。

什么是立即调用的函数表达式（IIFEs）？

IIFE是另一个函数表达式记法（显式的匿名函数），它在隔离状态下工作，独立于任何其他代码。它在被定义的地方被立即调用。

其语法如下：

(function (){
	//函数体
})();

IIFE的一个用例是包围一个你可能不会在代码中再次使用的变量。因此，一旦函数被执行，这个变量就不存在了。

如何在一个函数中使用关键字 return？

要创建一个在函数被调用后会解析为一个值的函数，你要在函数的正文中使用关键字 return。

return是一个指令，在函数中的代码被执行后，向函数返回一个值。

下面是一个函数的例子，该函数返回一个值，这个值在这个例子中是两个数字的总和：

function sum(a, b){
	return  a + b;
}

sum(10, 20);

//输出将是 30

在一个函数中使用 return 可以很容易地处理函数返回的数据，可以把它作为一个值传递给另一个函数，或者对它进行额外的操作。

JavaScript中的函数作用域（Scope）和闭包（Closures）是如何工作的？

一个作用域是一个嵌套的名字空间，它将在其中创建的名字本地化，这样这些名字就不会与在该作用域之外创建的类似名字发生冲突。在一个函数中，有一些作用域规则是适用的。

你定义的每个新函数都会创建一个新的作用域，称为函数作用域。在函数作用域内创建的变量在该作用域外是不可见的或不可访问的。

然而，在函数作用域之外但在定义函数的作用域内创建的变量可以在函数内被访问。因此，如果你在全局作用域内定义一个函数，它可以访问在该全局作用域内声明的所有变量。

此外，假设你有一个子函数（也就是内部函数）嵌套在父函数（也就是外部函数）里面。子函数可以访问其父函数中声明的所有变量和函数，以及父函数可以访问的所有变量和函数——即使其父函数已经执行完毕，并且其变量在该函数之外不再可以访问的情况下也可以。这个概念在 JavaScript 中被称为闭包。

然而，父函数不能访问在子函数内部创建的变量。这样一来，子函数内部的变量和函数就被限制在自己的作用域内。

让我们看一个这方面的代码例子：

//variables defined in the global scope

let  a = 40;
let b = 20;

//this function is also defined in the global scope

function parentFunc(){
	//access variables a and b inside this function

	console.log(a + b); 
}

//output: 60

假设我在父函数中嵌套了一个内部函数，像这样：

//全局范围内定义的变量

let a = 40;
let b = 20;

//这个函数也是在全局范围内定义的

function parentFunc(){
	let  name = “Doe”;
    
    //这个内部函数是在父函数范围内定义的
    
	function childFunc(){
		console.log(`${name} is ${a - b} years old`); 
      }
    return childFunc();
}

parentFunc(); //输出：Doe is 20 years old

现在，如果我在一个函数内创建一个变量，并试图从全局作用域访问它，我们会得到一个引用错误。这是因为该变量是函数作用域的局部变量，在全局作用域中是不可见的。

console.log(c);

function parentFunc(){
	let c = 30
} 

//输出：reference error - c is not defined

让我们试着访问一个在父函数中的嵌套函数内创建的变量：

function parentFunc(){
	console.log(age);
	function childFunc(){
		let  age = 20;
	} 
    return childFunc();
}

parentFunc(); //output: reference error - age is not defined.

默认形式参数如何在 JavaScript 中工作？

最初，当没有明确的值传给函数形式参数时，函数形式参数被分配为 undefined 。默认状态下形式参数让你在定义函数时为形式参数指定一个默认值，例如：

function greeting(name, message = ”Hello”){
	console. log(`${messgae}  ${name}`)
}

greeting(‘John’); //output: Hello John

//你还可以为默认参数分配一个新值
//当你调用这个函数时

greeting(‘Doe’, ‘Hi’); //output: Hi Doe

需要注意的是，在声明默认形式参数时，它必须在常规的形式参数之后。

剩余参数（rest parameter）如何在 JavaScript 中工作？

通过剩余参数，你可以定义一个函数，将多个实际参数存储在一个数组中。当你用多个实际参数来调用你的函数时这么做会特别有用，下面是一个例子：

function sayHello(message, ...names){
  names.forEach(name => console.log(`${message} ${name}`));
}

sayHello('Hello', "John", "Smith", "Doe");

/*
输出：

Hello John

Hello Smith

Hello Doe 

*/

...是使 names 成为剩余参数的原因。

就像默认形式参数一样, 剩余参数应该出现在你的函数中任何常规形式参数之后.

总结

在这篇文章中，你了解了 JavaScript 中的函数是怎么回事，以及如何编写你自己的函数。

有了函数，你就可以通过将所有的东西归入独立块，来执行不同的任务，从而组织你的代码。

我希望你喜欢这篇文章。要想了解更多关于函数的知识，你可以查看以下这些资源。

• JavaScript Functions
• Closures

文章就到这里， Happy coding :)