From 8dd53d74de7e86aad1350651f63ec79ee5105374 Mon Sep 17 00:00:00 2001 From: Glenn Fung <117829736+glenntfung@users.noreply.github.com> Date: Tue, 4 Nov 2025 14:41:44 -0600 Subject: [PATCH 1/5] Translation[CN]: basics --- cn/basics/README.md | 36 +++++++++++++ cn/basics/comments.md | 82 +++++++++++++++++++++++++++++ cn/basics/equality.md | 55 +++++++++++++++++++ cn/basics/types.md | 103 ++++++++++++++++++++++++++++++++++++ cn/basics/variables.md | 116 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 392 insertions(+) create mode 100644 cn/basics/README.md create mode 100644 cn/basics/comments.md create mode 100644 cn/basics/equality.md create mode 100644 cn/basics/types.md create mode 100644 cn/basics/variables.md diff --git a/cn/basics/README.md b/cn/basics/README.md new file mode 100644 index 00000000..813293ea --- /dev/null +++ b/cn/basics/README.md @@ -0,0 +1,36 @@ +--- +layout: editorial +chapter: 2 +pageNumber: 11 +description: Programming means writing code. A book is made up of chapters, paragraphs, sentences, phrases, words, and finally punctuation and letters, likewise a program can be broken down into smaller and smaller components. +--- + + +# 第2章 + +# 基础 + +在本章的开头，我们将学习编程与 JavaScript 语言的基础知识。 + +编程就是编写代码。就像一本书由章、段落、句子、词组、单词，最终到标点符号与字母构成一样，程序也可以被拆分为越来越小的组成部分。当前最重要的部分是“语句”。语句类似于书中的句子。它自身有结构与目的，但如果脱离周围其他语句的上下文，它的意义就不那么充分。 + +语句在口语中（也是更常见的说法）被称为一 *行代码*。这是因为语句通常写在单独的行上。因此，程序是自上而下、从左到右阅读的。你也许会好奇，什么是代码（也称源代码）。这是一个很宽泛的术语，既可以指整个程序，也可以指最小的部分。因此，一行代码就是你程序中的一行。 + +下面是一个简单示例： + +```javascript +let hello = "Hello"; +let world = "World"; + +// message等于 "Hello World" +let message = hello + " " + world; +``` + +这段代码可以由另一个称为 *解释器* 的程序来执行，它会读取代码并以正确的顺序执行所有语句。 + +在本章中，我们将探讨以下主题： + +* [注释](./comments.md) +* [相等性](./equality.md) +* [类型](./types.md) +* [变量](./variables.md) \ No newline at end of file diff --git a/cn/basics/comments.md b/cn/basics/comments.md new file mode 100644 index 00000000..7760463f --- /dev/null +++ b/cn/basics/comments.md @@ -0,0 +1,82 @@ +--- +chapter: 2 +pageNumber: 12 +description: Comments are used to mark annotations for other programmers or small descriptions about the code that helps others to understand it. These statement are not executed by the interpreter. +--- + +# 注释 + +注释是不会被解释器执行的语句。它们用于为其他程序员做标注或对代码的作用进行简短说明，从而让他人更容易理解你的代码。注释也可用于在不影响程序控制流的情况下临时禁用代码。 + +## 注释的类型 + +### 单行注释 + +单行注释以两个正斜杠（`//`）开始，并持续到该行末尾。斜杠之后的任何内容都会被 JavaScript 解释器忽略。 + +```javascript +// 这是一条注释，解释器会忽略它 +let a = "This is a variable"; +``` + +你也可以在行尾使用它们： + +```javascript +let b = 5; // 这也是一个有效的单行注释 +``` + +### 多行注释 + +多行注释以 `/*` 开始并以 `*/` 结束。两者之间的内容都会被忽略。 + +```javascript +/* + 这是一个多行注释。 + 你可以用它来解释更复杂的逻辑 + 或者暂时屏蔽一段代码。 +*/ +let x = 10; +``` + +### 现实中的注释示例 + +```javascript +// 修改标题： +document.getElementById("myH").innerHTML = "My First Page"; + +// 修改段落： +document.getElementById("myP").innerHTML = "My first paragraph."; +``` + +```javascript +/* + 在测试新的 UI 流程时，暂时禁用欢迎消息。 +*/ + +/* +document.getElementById("myH").innerHTML = "Welcome back!"; +document.getElementById("myP").innerHTML = "We're glad to see you again."; +*/ +``` + +它们对调试也很有用： + +```javascript +let total = 0; +// total = calculateTotal(items); // 测试期间暂时禁用 +``` + +```javascript +/* + 登录问题的调试日志 + 问题解决后已注释掉 +*/ + +/* +console.log("User data:", user); +console.log("Auth token:", token); +console.log("Response from API:", response); +*/ +``` + +在代码中包含注释对于维护代码质量、促进协作以及简化调试过程至关重要。通过为程序的各个部分提供上下文与解释，注释能让将来更容易理解代码。因此，在代码中编写注释被视为一种良好的实践。 \ No newline at end of file diff --git a/cn/basics/equality.md b/cn/basics/equality.md new file mode 100644 index 00000000..8e577998 --- /dev/null +++ b/cn/basics/equality.md @@ -0,0 +1,55 @@ +--- +chapter: 2 +pageNumber: 17 +description: The equality operator is used for comparision. It can to determine if two variables are equal, even if they are not of the same type. +--- + +# 相等性 + +在编写程序时，我们经常需要判断变量与其他变量是否相等。这通过相等运算符来完成。最基本的相等运算符是 `==`。该运算符会尽其所能判断两个变量是否相等，即使它们的类型并不相同。 + +例如，假设： + +```javascript +let foo = 42; +let bar = 42; +let baz = "42"; +let qux = "life"; +``` + +`foo == bar` 的结果为 `true`，`baz == qux` 的结果为 `false`，这与直觉一致。然而，尽管 `foo` 和 `baz` 的类型不同，`foo == baz` 也会得到 `true`。在幕后，`==` 相等运算符会在判断是否相等之前，尝试将其操作数强制转换为同一类型。这与 `===` 相等运算符形成对比。 + +`===` 相等运算符只有在两个变量类型相同 *并且* 值也相同时才认为它们相等。沿用上面的假设，这意味着 `foo === bar` 仍然为 `true`，但 `foo === baz` 现在为 `false`。`baz === qux` 依然为 `false`。 + +{% exercise %} +使用 `==` 和 `===` 运算符比较 `str1` 和 `str2` 的值。 + +{% initial %} +let str1 = "hello"; +let str2 = "HELLO"; +let bool1 = true; +let bool2 = 1; +// 使用 == 比较 +let stringResult1 = +let boolResult1 = +// 使用 === 比较 +let stringResult1 = +let boolResult2 = +{% solution %} +let str1 = "hello"; +let str2 = "HELLO"; +let bool1 = true; +let bool2 = 1; +// 使用 == 比较 +let stringResult1 = str1 == str2 // false +let boolResult1 = bool1 == bool2 // true + +// 使用 === 比较 +let stringResult2 = str1 === str2 // false +let boolResult2 = bool1 === bool2 // false + +{% validation %} +assert(stringResult1 === false && stringResult2 === false && boolResult1 ==true && boolResult2 === false ); + +{% context %} +{% endexercise %} diff --git a/cn/basics/types.md b/cn/basics/types.md new file mode 100644 index 00000000..2ef21081 --- /dev/null +++ b/cn/basics/types.md @@ -0,0 +1,103 @@ +--- +chapter: 2 +pageNumber: 15 +description: Types are the kinds of data that can be represented and manipulated in the language. +--- + +# 变量类型 + +计算机足够复杂，能使用比数字更复杂的变量。这就是变量类型的作用所在。变量有多种类型，不同语言支持的类型也不尽相同。 + +最常见的类型有： + +* **Number**：数字可以是整数（如 `1`、`-5`、`100`）或浮点数（如 `3.14`、`-2.5`、`0.01`）。JavaScript 不区分整数与浮点数；两者都被视为数字。 +* **String**：字符串是由字符组成的序列，可以用单引号（如 `'hello'`）或双引号（如 `"world"`）表示。 +* **Boolean**：布尔值表示真或假，可写为 `true` 或 `false`（不加引号）。 +* **Null**：null 类型表示空值，含义是“没有值”。写作 `null`（不加引号）。 +* **Undefined**：undefined 类型表示尚未被赋值的值。如果一个变量已声明但未被赋值，它就是 `undefined`。 +* **Object**：对象是属性的集合，每个属性都有名称和对应的值。可以使用花括号（`{}`）创建对象，并以“名称-值”对的方式为其赋予属性。 +* **Array**：数组是一种特殊的对象类型，用来保存一组条目。可以使用方括号（`[]`）创建数组，并为其赋予一个值列表。 +* **Function**：函数是一段可以定义并通过名称调用的代码。[函数](../functions/README.md)可以接收参数（输入）并返回一个值（输出）。可以使用 `function` 关键字创建函数。 + +JavaScript 是一种“*弱类型*”语言，这意味着你不必显式声明变量的数据类型。只需使用 `var` 关键字表明你在声明变量，解释器会根据上下文与是否使用引号推断你所使用的数据类型。 + +{% exercise %} +声明三个变量并用以下值初始化：将 `age` 设为数字、`name` 设为字符串、`isMarried` 设为布尔值。 + +{% initial %} +let age = +let name = +let isMarried = +{% solution %} +let age = 30 +let name = "Cecilia" +let isMarried = true + +{% validation %} +assert(typeof age === "number" && typeof name === "string" && typeof isMarried === "boolean"); + +{% context %} +{% endexercise %} + +`typeof` 运算符用于检查变量的数据类型。 + +```javascript +typeof "John" // 返回 "string" +typeof 3.14 // 返回 "number" +typeof NaN // 返回 "number" +typeof false // 返回 "boolean" +typeof [1,2,3,4] // 返回 "object" +typeof {name:'John', age:34} // 返回 "object" +typeof new Date() // 返回 "object" +typeof function () {} // 返回 "function" +typeof myCar // 返回 "undefined" * +typeof null // 返回 "object +``` + +JavaScript 中使用的数据类型可以按“是否能包含值”分为两类。 + +可以包含值的数据类型： + +* `string` +* `number` +* `boolean` +* `object` +* `function` + +{% hint style="info" %} +`Object`、`Date`、`Array`、`String`、`Number` 与 `Boolean` 是 JavaScript 中可用的对象类型。 +{% endhint %} + +不能包含值的数据类型： + +* `null` +* `undefined` + +原始（primitive）数据值是没有附加属性与方法、且不是对象的简单数据值。它们是不可变的，也就是不能被就地修改。共有 7 种原始数据类型： + +* string +* number +* bigint +* boolean +* undefined +* symbol +* null + +{% exercise %} +声明一个名为 `person` 的变量，并用一个对象初始化它。该对象包含以下属性：`age` 为数字、`name` 为字符串、`isMarried` 为布尔值。 + +{% initial %} +let person = + +{% solution %} +let person = { +name: "Mary", +age: 25, +isMarried: false +}; + +{% validation %} +assert(typeof person.age === "number" && typeof person.name === "string" && typeof person.isMarried === "boolean"); + +{% context %} +{% endexercise %} diff --git a/cn/basics/variables.md b/cn/basics/variables.md new file mode 100644 index 00000000..beb223ec --- /dev/null +++ b/cn/basics/variables.md @@ -0,0 +1,116 @@ +--- +chapter: 2 +pageNumber: 13 +description: Variables are used to store and hold data. It can hold various types of values, such as numbers, strings, booleans, objects, arrays, functions and more. +--- + +# 变量 + +真正理解编程的第一步是回到代数。如果你还记得在学校学的内容，代数从书写如下项开始。 + +```javascript +3 + 5 = 8 +``` + +当你引入一个未知数时就开始进行计算，例如下面的 `x`： + +```javascript +3 + x = 8 +``` + +通过移项，你可以确定 `x`： + +```javascript +x = 8 - 3 +-> x = 5 +``` + +当你引入不止一个未知数时，你的式子会更灵活——这就是在使用变量： + +```javascript +x + y = 8 +``` + +你可以改变 `x` 和 `y` 的值，而这个公式仍然可以成立： + +```javascript +x = 4 +y = 4 +``` + +或者 + +```javascript +x = 3 +y = 5 +``` + +编程语言也是如此。在编程中，变量是装载会变化的值的容器。变量可以保存各种值，也可以保存计算的结果。变量有一个用等号 `(=)` 连接的 `名称` 和 `值`。不过，要牢记不同的编程语言对变量名各自有一定的限制与约束，因为语言中的某些词可能被保留用于特定的函数或操作。 + +来看一下在 JavaScript 中它是如何工作的。下面的代码定义了两个变量，计算它们相加的结果，并将该结果作为第三个变量的值。 + +```javascript +let x = 5; +let y = 6; +let result = x + y; +``` + +命名变量时需要遵循一些准则： + +* 变量名必须以字母、下划线 `(_)` 或美元符号 `($)` 开头。 +* 在首字符之后，可以使用*字母*、*数字*、*下划线*或*美元符号*。 +* JavaScript 区分大小写，因此 `myVariable`、`MyVariable` 和 `MYVARIABLE` 是三个不同的变量。 +* 为了让代码易于阅读和维护，建议使用能准确反映用途的描述性变量名。 + +{% exercise %} +将变量 `x` 定义为 20。 + +{% initial %} +let x = + +{% solution %} +let x = 20; + +{% validation %} +assert(x == 20); + +{% context %} +{% endexercise %} +**ES6 版本** + +[ECMAScript 2015 或 ES2015](https://262.ecma-international.org/6.0/)，也称为 E6，是自 2009 年以来对 JavaScript 的一次重要更新。在 ES6 中，我们有三种声明变量的方式。 + +```javascript +var x = 5; +const y = 'Test'; +let z = true; +``` + +声明方式的差异体现在作用域上。与不考虑块级作用域、在全局或整个函数内声明变量的 `var` 不同，`let` 允许你将变量的作用域限制在其所处的代码块、语句或表达式中。例如： + +```javascript +function varTest(){ + var x=1; + if(true){ + var x=2; // 同一个变量 + console.log(x); //2 + } + console.log(x); //2 +} + +function letTest(){ + let x=1; + if(true){ + let x=2; + console.log(x); // 2 + } + console.log(x); // 1 +} +``` + +`const` 变量是不可变的，这意味着它们不允许被重新赋值。 + +```javascript +const x = "hi!"; +x = "bye"; // 这将导致错误 +``` From 8bb1e4cd32645b7be458c0cf759fcdf5969267d5 Mon Sep 17 00:00:00 2001 From: Glenn Fung <117829736+glenntfung@users.noreply.github.com> Date: Sun, 30 Nov 2025 23:41:09 -0600 Subject: [PATCH 2/5] fix: quote typo It says single quote in the comment, so the example should be single quote --- en/strings/create.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/en/strings/create.md b/en/strings/create.md index 3d220daf..73dabdf1 100644 --- a/en/strings/create.md +++ b/en/strings/create.md @@ -8,7 +8,7 @@ Strings can be defined by enclosing the text in single quotes or double quotes: ```javascript // Single quotes can be used -let str = "Our lovely string"; +let str = 'Our lovely string'; // Double quotes as well let otherStr = "Another nice string"; From 24f8de76a6c0335cf409a0f31b82834ea286f6be Mon Sep 17 00:00:00 2001 From: Glenn Fung <117829736+glenntfung@users.noreply.github.com> Date: Sun, 30 Nov 2025 23:51:14 -0600 Subject: [PATCH 3/5] Translation[CN]: numbers & strings --- cn/numbers/README.md | 48 +++++ cn/numbers/advanced.md | 112 +++++++++++ cn/numbers/math.md | 73 ++++++++ cn/numbers/operators.md | 398 ++++++++++++++++++++++++++++++++++++++++ cn/strings/README.md | 61 ++++++ cn/strings/charAt.md | 53 ++++++ cn/strings/concat.md | 33 ++++ cn/strings/create.md | 65 +++++++ cn/strings/length.md | 27 +++ cn/strings/replace.md | 31 ++++ cn/strings/split.md | 47 +++++ cn/strings/substring.md | 59 ++++++ 12 files changed, 1007 insertions(+) create mode 100644 cn/numbers/README.md create mode 100644 cn/numbers/advanced.md create mode 100644 cn/numbers/math.md create mode 100644 cn/numbers/operators.md create mode 100644 cn/strings/README.md create mode 100644 cn/strings/charAt.md create mode 100644 cn/strings/concat.md create mode 100644 cn/strings/create.md create mode 100644 cn/strings/length.md create mode 100644 cn/strings/replace.md create mode 100644 cn/strings/split.md create mode 100644 cn/strings/substring.md diff --git a/cn/numbers/README.md b/cn/numbers/README.md new file mode 100644 index 00000000..9ac44dcc --- /dev/null +++ b/cn/numbers/README.md @@ -0,0 +1,48 @@ +--- +layout: editorial +chapter: 3 +pageNumber: 18 +description: Numbers refer to the data type used to represent numeric values. Numbers in JavaScript can be either integers (whole numbers) or floating-point numbers (decimal numbers) +--- + +# 第3章 + +# 数字 + +JavaScript 只有**一种数值类型**——64 位浮点数。这与 Java 的 `double` 相同。不同于大多数其他编程语言，它没有单独的整数类型，所以 1 和 1.0 是相同的值。创建一个数值很容易，就像为其他变量类型那样使用 `var` 关键字即可。 + +数值可以由常量创建： + +```javascript +// 这是一个浮点数： +let a = 1.2; + +// 这是一个整数： +let b = 10; +``` + +也可以由另一个变量的值创建： + +```javascript +let a = 2; +let b = a; +``` + +整数的精度可精确到 15 位，且最大可表示的有效数字约为 17 位。 + +```javascript +let x = 999999999999999; // x 将是 999999999999999 +let y = 9999999999999999; // y 将是 10000000000000000 +``` + +如果数值常量以前缀 `0x` 开头，则会被解释为十六进制。 + +```javascript +let z = 0xFF; // 255 +``` + +在本章中，我们将探讨以下主题： + +* [数学](./math.md) +* [基本运算符](./operators.md) +* [高级运算符](./advanced.md) diff --git a/cn/numbers/advanced.md b/cn/numbers/advanced.md new file mode 100644 index 00000000..c5649b00 --- /dev/null +++ b/cn/numbers/advanced.md @@ -0,0 +1,112 @@ +--- +chapter: 3 +pageNumber: 28 +description: There are several advanced operators that provide powerful functionality and allow us to perform various operations beyond basic arithmetic and logical operations. These advanced operators can be very helpful for manipulating data, performing bitwise operations, working with objects, and more. +--- + +# 高级运算符 + +当多个运算符在没有使用括号的情况下连在一起时，它们的执行顺序由运算符的 *优先级* 决定。乘法 `(*)` 与除法 `(/)` 的优先级高于加法 `(+)` 与减法 `(-)`。 + +```javascript +// 先进行乘法运算，然后再进行加法 +let x = 100 + 50 * 3; // 250 +// 使用括号时，括号中的运算会优先计算 +let y = (100 + 50) * 3; // 450 +// 拥有相同优先级的运算会从左到右依次计算 +let z = 100 / 50 * 3; +``` + +在编写程序时，可以使用若干高级数学运算符。下面列出了一些主要的高级数学运算符： + +* **取模运算符 (`%`)**：取模运算符返回除法运算的余数。例如： + +```javascript +console.log(10 % 3); // 1 +console.log(11 % 3); // 2 +console.log(12 % 3); // 0 +``` + +* **幂运算符 (* *)**：幂运算符将一个数字提升为另一个数字的幂。它是一个较新的运算符，并未被所有浏览器支持，因此你可能需要使用 `Math.pow` 函数来代替。例如： + +```javascript +console.log(2 ** 3); // 8 +console.log(3 ** 2); // 9 +console.log(4 ** 3); // 64 +``` + +* **自增运算符 (`++`)**：自增运算符将数字加一。它可以作为前缀（在操作数前）或后缀（在操作数后）使用。例如： + +```javascript +let x = 1; +x++; // x 现在是 2 +++x; // x 现在是 3 +``` + +* **自减运算符 (`--`)**：自减运算符将数字减一。它可以作为前缀（在操作数前）或后缀（在操作数后）使用。例如： + +```javascript +let y = 3; +y--; // y 现在是 2 +--y; // y 现在是 1 +``` + +* **Math 对象**：`Math` 对象是 JavaScript 中的内置对象，提供了数学函数和常量。你可以使用 `Math` 对象的方法来执行高级数学运算，例如求一个数的平方根、计算一个数的正弦值或生成一个随机数。例如： + +```javascript +console.log(Math.sqrt(9)); // 3 +console.log(Math.sin(0)); // 0 +console.log(Math.random()); // 0 到 1 之间的随机数 +``` + +这些只是 JavaScript 中可用的高级数学运算符和函数的一些例子。还有很多其它的运算符和函数可以在编写程序时用于执行更复杂的数学运算。 + +{% exercise %} +使用以下高级运算符对 `num1` 和 `num2` 进行运算。 + +{% initial %} +let num1 = 10; +let num2 = 5; + +// 使用 ++ 运算符将 num1 的值加一。 +const result1 = +// 使用 -- 运算符将 num2 的值减一。 +const result2 = +// 使用 += 运算符将 num2 加到 num1 上。 +const result3 = +// 使用 -= 运算符将 num2 从 num1 中减去。 +const result4 = + +{% solution %} +let num1 = 10; +let num2 = 5; + +// 使用 ++ 运算符将 num1 的值加一。 +num1++; +const result1 = num1; // 11 +// 使用 -- 运算符将 num2 的值减一。 +num2--; +const result2 = num2; // 4 +// 使用 += 运算符将 num2 加到 num1 上。 +num1 += num2; +const result3 = num1 // 15 +// 使用 -= 运算符将 num2 从 num1 中减去。 +num1 -= num2; +const result4 = num1 // 11 + +{% validation %} +assert(result1 === 11 && result2 === 4 && result3 === 15 && result4 === 11 ); + +{% context %} +{% endexercise %} + +## 空值合并运算符 '??' + +`nullish` 合并运算符会在第一个参数不是 `null/undefined` 时返回第一个参数，否则返回第二个参数。它写作连续两个问号 `??`。表达式 `x ?? y` 的结果是： + +* 如果 `x` 已被定义，则结果为 `x`； +* 否则结果为 `y`。 + +{% hint style="info" %} +这是对该语言的一个较新的扩展，为了在旧浏览器中支持它，可能需要使用 polyfill。 +{% endhint %} diff --git a/cn/numbers/math.md b/cn/numbers/math.md new file mode 100644 index 00000000..01475547 --- /dev/null +++ b/cn/numbers/math.md @@ -0,0 +1,73 @@ +--- +chapter: 3 +pageNumber: 19 +description: The Math object allows performing mathematical operations in JavaScript. It is static and doesn't have a constructor. One can use method and properties of Math object without creating a Math object first. +--- + +# 数学 + +`Math` 对象用于在 JavaScript 中执行数学运算。它是静态的，没有构造函数。无需先创建一个 Math 对象即可使用其方法和属性。要访问它的属性，可以使用 *Math.property.*。下面描述了一些数学属性： + +```javascript +Math.E; // 返回欧拉常数 +Math.PI; // 返回圆周率 +Math.SQRT2; // 返回 2 的平方根 +Math.SQRT1_2; // 返回 1/2 的平方根 +Math.LN2; // 返回 2 的自然对数 +Math.LN10; // 返回 10 的自然对数 +Math.LOG2E; // 返回以 2 为底的 E 的对数 +Math.LOG10E; // 返回以 10 为底的 E 的对数 +``` + +一些数学方法的示例： + +```javascript +Math.pow(8, 2); // 64 +Math.round(4.6); // 5 +Math.ceil(4.9); // 5 +Math.floor(4.9); // 4 +Math.trunc(4.9); // 4 +Math.sign(-4); // -1 +Math.sqrt(64); // 8 +Math.abs(-4.7); // 4.7 +Math.sin((90 * Math.PI) / 180); // 1（90 度的正弦） +Math.cos((0 * Math.PI) / 180); // 1（0 度的余弦） +Math.min(0, 150, 30, 20, -8, -200); // -200 +Math.max(0, 150, 30, 20, -8, -200); // 150 +Math.random(); // 0.44763808380924375 +Math.log(2); // 0.6931471805599453 +Math.log2(8); // 3 +Math.log10(1000); // 3 +``` + +要使用数学方法，可以在需要的地方直接带上参数调用其方法。 + +| 方法 | 描述 | +| ------------------ | -------------------------------------------------------------- | +| `abs(x)` | 返回 `x` 的绝对值 | +| `acos(x)` | 返回 `x` 的反余弦，单位为弧度 | +| `acosh(x)` | 返回 `x` 的反双曲余弦 | +| `asin(x)` | 返回 `x` 的反正弦，单位为弧度 | +| `asinh(x)` | 返回 `x` 的反双曲正弦 | +| `atan(x)` | 以数值形式返回 `x` 的反正切，范围在 `-PI/2` 到 `PI/2` 弧度之间 | +| `atan2(y,x)` | 返回其参数商的反正切 | +| `atanh(x)` | 返回 `x` 的反双曲正切 | +| `crbt(x)` | 返回 `x` 的立方根 | +| `ceil(x)` | 将 `x` 向上取整到最接近的整数 | +| `cos(x)` | 返回 `x` 的余弦，单位为弧度 | +| `cosh(x)` | 返回 `x` 的双曲余弦 | +| `exp(x)` | 返回 `x` 的指数值 | +| `floor(x)` | 将 `x` 向下取整到最接近的整数 | +| `log(x)` | 返回 `x` 的自然对数 | +| `max(x,y,z,... n)` | 返回值最大的那个数 | +| `min(x,y,z,... n)` | 返回值最小的那个数 | +| `pow(x,y)` | 返回 `x` 的 `y` 次幂 | +| `random()` | 返回 0 到 1 之间的数 | +| `round(x)` | 将数字四舍五入到最接近的值 | +| `sign(x)` | 返回 x 是负、`null` 还是正 (-1,0,1) | +| `sin(x)` | 返回 `x` 的正弦，单位为弧度 | +| `sinh(x)` | 返回 `x` 的双曲正弦 | +| `sqrt(x)` | 返回 `x` 的平方根 | +| `tan(x)` | 返回一个角的正切 | +| `tanh(x)` | 返回 `x` 的双曲正切 | +| `trunc(x)` | 返回一个数（`x`）的整数部分 | \ No newline at end of file diff --git a/cn/numbers/operators.md b/cn/numbers/operators.md new file mode 100644 index 00000000..b5e5d047 --- /dev/null +++ b/cn/numbers/operators.md @@ -0,0 +1,398 @@ +--- +chapter: 3 +pageNumber: 21 +description: Operators are symbols or keywords used to perform operations on data, such as variables, values, or expressions. They are an essential part of the language and allow developers to perform arithmetic, comparison, logical, assignment, and other operations. +--- + +# 基本运算符 + +在 JavaScript 中，运算符是用于对操作数（值和变量）执行运算的符号或关键词。例如： + +```javascript +2 + 3; //5 +``` + +这里的 `+` 是执行加法运算的运算符，而 `2` 和 `3` 是操作数。 + +## 运算符的类型 + +JavaScript 支持多种运算符，包括： + +* [算术运算符](#arithmetic-operators) +* [赋值运算符](#assignment-operators) +* [比较运算符](#Comparison-operators) +* [逻辑运算符](#logical-operators) +* [三元运算符](#ternary-operators) +* [按位运算符](#bitwise-operators) +* [`typeof` 运算符](#typeof-operators) + +### 算术运算符 {#arithmetic-operators} + +算术运算符用于对值执行数学运算。包括： + +* [加法 (`+`) 运算符](#addition-operator) +* [减法 (`-`) 运算符](#subtraction-operator) +* [乘法 (`*`) 运算符](#multiplication-operator) +* [除法 (`/`) 运算符 ](#multiplication-operator) +* [取余 (`%`) 运算符](#remainder-operator) + +#### 加法运算符（`+`） {#addition-operator} + +加法运算符用于将两个数字相加。例如： + +```javascript +console.log(1 + 2); // 3 +console.log(1 + -2); // -1 +``` + +#### 减法运算符（`-`） {#subtraction-operator} + +减法运算符用于用一个数减去另一个数。例如： + +```javascript +console.log(3 - 2); // 1 +console.log(3 - -2); // 5 +``` + +#### 乘法运算符（`*`） {#multiplication-operator} + +乘法运算符用于将两个数字相乘。例如： + +```javascript +console.log(2 * 3); // 6 +console.log(2 * -3); // -6 +``` + +#### 除法运算符（`/`） {#division-operator} + +除法运算符用于用一个数除以另一个数。例如： + +```javascript +console.log(6 / 2); // 3 +console.log(6 / -2); // -3 +``` + +#### 取余运算符（`%`） {#remainder-operator} + +取余运算符返回一次除法运算的余数。例如： + +```javascript +console.log(10 % 3); // 1 +console.log(11 % 3); // 2 +console.log(12 % 3); // 0 +``` + +JavaScript 解释器自左向右执行。可以像数学中那样使用括号来分隔和分组表达式：`c = (a / b) + d` + +{% hint style="working" %} +JavaScript 使用 `+` 运算符同时完成加法和字符串拼接。对数字执行时是加法，对字符串执行时是拼接。 +{% endhint %} + +术语 `NaN` 是一个保留字，用来表示一个数不是合法的数字。当我们对非数值字符串做算术运算时，就会产生 `NaN`（Not a Number，非数字）。 + +```javascript +let x = 100 / "10"; +``` + +`parseInt` 方法会将一个值按字符串解析，并返回首个整数部分。 + +```javascript +parseInt("10"); // 10 +parseInt("10.00"); // 10 +parseInt("10.33"); // 10 +parseInt("34 45 66"); // 34 +parseInt(" 60 "); // 60 +parseInt("40 years"); //40 +parseInt("He was 40"); //NaN +``` + +在 JavaScript 中，如果我们计算得到的数字超过了可能的最大数值，它会返回 `Infinity`。 + +```javascript +let x = 2 / 0; // Infinity +let y = -2 / 0; // -Infinity +``` + +{% exercise %} +使用数学运算符 +、-、*、/ 和 % 对 `num1` 和 `num2` 执行下列运算。 + +{% initial %} +let num1 = 10; +let num2 = 5; + +// Add num1 and num2. +let addResult = +// Subtract num2 from num1. +let subtractResult = +// Multiply num1 and num2. +let multiplyResult = +// Divide num1 by num2. +let divideResult = +// Find the remainder num1 is divided by num2. +let reminderResult = + +{% solution %} +let num1 = 10; +let num2 = 5; + +// Add num1 and num2. +let addResult = (num1 + num2); +// Subtract num2 from num1. +let subtractResult = (num1 - num2); +// Multiply num1 and num2. +let multiplyResult = (num1 * num2); +// Divide num1 by num2. +let divideResult = (num1 / num2); +// Find the remainder num1 is divided by num2. +let reminderResult = (num1 % num2); + +{% validation %} +assert(addResult === 15 && subtractResult === 5 && multiplyResult === 50 && divideResult === 2 && reminderResult === 0 ); + +{% context %} +{% endexercise %} + +### 赋值运算符 {#assignment-operators} + +赋值运算符用于给变量赋值，或者对赋值的结果进行求值。*也可以将赋值运算符串联，以便把同一个值赋给多个变量。* 它们包括赋值（`=`）运算符以及诸如 `+=`、`-=`、`*=` 和 `/=` 等复合赋值运算符。 + +#### `=`（赋值运算符） + +该运算符用于将右侧的值赋给左侧的变量。 +例如： + +```javascript +let x = 10; //Assigns the value 10 to the variable x. +``` + +#### 复合赋值运算符 + +这些运算符把算术运算与赋值运算结合在一起。它们是“先运算再把结果重新赋值给变量”的快捷写法。 +例如： + +##### `+=`（加法赋值） + +将右侧的值加到变量上，并把结果重新赋值给该变量。 + +##### `-=`（减法赋值） + +从变量中减去右侧的值，并把结果重新赋值给该变量。 + +##### `*=-`（乘法赋值） + +将变量与右侧的值相乘，并把结果重新赋值给该变量。 + +##### `/=`（除法赋值） + +用变量除以右侧的值，并把结果重新赋值给该变量。 + +##### `%=`（取模/取余赋值） + +计算变量被右侧的值除时的余数，并把结果重新赋值给该变量。 + +```javascript +let a = 10; +a += 5; // Equivalent to a = a + 5; (a becomes 15) +a -= 3; // Equivalent to a = a - 3; (a becomes 12) +a *= 2; // Equivalent to a = a * 2; (a becomes 24) +a /= 4; // Equivalent to a = a / 4; (a becomes 6) +a %= 5; // Equivalent to a = a % 5; (a becomes 1) +``` + +### 比较运算符 {#Comparison-operators} + +比较运算符用于比较两个值或表达式，并返回一个 `boolean` 结果，即 `true` 或 `false`。这些运算符通常用于条件语句中，用来做出决策或判断条件。 + +#### 等于（`==`） + +该运算符检查左右两侧的值是否相等。如果相等，返回 `true`，否则返回 `false`。它不考虑数据类型。 + +```javascript +5 == 5; // true +"5" == 5; // true (implicit type conversion) +``` + +#### 不等于（`!=`） + +该运算符检查左右两侧的值是否不相等。如果不相等，返回 `true`，否则返回 `false`。 + +```javascript +5 != 3; // true +"5" != 5; // false (implicit type conversion) +``` + +#### 全等于（`===`） + +该运算符检查左右两侧的值是否相等且数据类型是否相同。如果值与数据类型都匹配，返回 `true`，否则返回 `false`。 + +```javascript +5 === 5; // true +"5" === 5; // false (different data types) +``` + +#### 全不等于（`!==`） + +该运算符检查左右两侧的值是否不相等，或者数据类型是否不同。如果值不相等或数据类型不同，则返回 `true`，否则返回 `false`。 + +```javascript +5 !== "5"; // true (different data types) +5 !== 5; // false +``` + +#### 大于（`>`） + +该运算符检查左侧值是否大于右侧值。如果左侧值更大，则返回 `true`，否则返回 `false`。 + +```javascript +8 > 5; // true +3 > 10; // false +``` + +#### 小于（`<`） + +该运算符检查左侧值是否小于右侧值。如果左侧值更小，则返回 `true`，否则返回 `false`。 + +```javascript +3 < 5; // true +8 < 2; // false +``` + +#### 大于等于（`>=`） + +该运算符检查左侧值是否大于或等于右侧值。如果左侧值大于或等于右侧值，则返回 `true`，否则返回 `false`。 + +```javascript +8 >= 5; // true +3 >= 8; // false +``` + +#### 小于等于（`>=`） + +该运算符检查左侧值是否小于或等于右侧值。如果左侧值小于或等于右侧值，则返回 `true`，否则返回 `false`。 + +```javascript +3 <= 5; // true +8 <= 2; // false +``` + +### 逻辑运算符 {#logical-operators} + +逻辑运算符用于对布尔值或表达式执行逻辑运算。它们允许你组合或处理布尔值，从而做出决策或判断更复杂的条件。 + +#### 逻辑与（`&&`） + +逻辑与运算符在两个操作数都为 `true` 时返回 `true`。只要有一个操作数为 `false`，就返回 `false`。 + +```javascript +true && true; // true +true && false; // false +false && true; // false +false && false; // false +``` + +#### 逻辑或（`||`） + +逻辑或运算符只要至少有一个操作数为 `true` 就返回 `true`。只有当两个操作数都为 `false` 时才返回 `false`。 + +```javascript +true || true; // true +true || false; // true +false || true; // true +false || false; // false +``` + +#### 逻辑非（`!`） + +逻辑非运算符会对操作数的值取反。当操作数为 `false` 时返回 `true`，当操作数为 `true` 时返回 `false`。 + +```javascript +!true; // false +!false; // true +``` + +### 三元运算符 {#ternary-operators} + +三元运算符有三个操作数。它是 `if/else` 的简写形式。 + +它是 `if-else` 条件语句的简写形式。 + +**语法** +**Syntax** + +```js +Y = ? A : B +If the condition is true then Y = A otherwise Y = B +``` + +```javascript +let isEven = 8 % 2 === 0 ? "Even" : "Odd"; +console.log(isEven); // "Even" +``` + +### 按位运算符 {#bitwise-operators} + +按位运算符用于操作二进制数的各个位。它们在位级别上执行运算，在需要控制或分析底层数据的场景中尤其有用。 + +#### 按位与（`&`） + +该运算符比较两个数的每一位，如果在两个数中对应位都为 1，则该位结果为 1；其它情况结果为 0。 + +```javascript +1010 & 1100; // 1000 +``` + +#### 按位或（`|`） + +该运算符比较两个数的每一位，只要在任意一个数中该位为 1，则该位结果为 1。 + +```javascript +1010 | 1100; // 1110 +``` + +#### 按位异或（`^`） + +该运算符比较两个数的每一位，如果在两个数中该位有且只有一个为 1，则该位结果为 1。 + +```javascript +1010 ^ 1100; // 0110 +``` + +#### 按位非（`-`） + +该运算符会对一个数的所有位取反：把 0 变成 1，把 1 变成 0。 + +```javascript +~1010; // 0101 +``` + +#### 左移（`<<`） + +该运算符将一个数的二进制位向左移动指定的位数，右侧移入的位置用 0 填充。 + +```javascript +1010 << 2; // 101000 (shifted left by 2 positions) +``` + +#### 右移（`>>`） + +该运算符将一个数的二进制位向右移动指定的位数。左侧移入的位置会根据最左边的位（符号位）进行填充。 + +```javascript +1010 >> 2; // 0010 (shifted right by 2 positions) +``` + +### `typeof` 运算符 {#typeof-operators} + +它返回操作数的类型。JavaScript 中可能的类型包括：undefined、Object、boolean、number、string、symbol 和 function。 + +```javascript +let value1 = 42; +let value2 = "Hello, World!"; +let value3 = true; +let value4 = null; + +console.log(typeof value1); // "number" +console.log(typeof value2); // "string" +console.log(typeof value3); // "boolean" +console.log(typeof value4); // "object" (Note: `typeof null` returns "object" due to historical reasons) +``` diff --git a/cn/strings/README.md b/cn/strings/README.md new file mode 100644 index 00000000..227c5210 --- /dev/null +++ b/cn/strings/README.md @@ -0,0 +1,61 @@ +--- +layout: editorial +chapter: 4 +pageNumber: 30 +--- + +# 第4章 +# 字符串 + +JavaScript 字符串在很多方面与其他高级语言中的字符串实现类似。它们用于表示基于文本的消息和数据。在本课程中，我们将讲解基础内容，包括如何创建新的字符串以及在其上执行常见操作。 + +下面是一个字符串示例： + +``` +"Hello World" +``` + +字符串的索引从 0 开始，这意味着第一个字符的位置是 `0`，后续字符依次递增。字符串支持多种方法，这些方法会返回一个新值。下面对这些方法进行说明。 + +| Name | Description | +| -------------------- | ------------------------------------------------------ | +| `charAt()` | 返回指定索引位置的字符 | +| `charCodeAt()` | 返回指定索引位置字符的 Unicode 值 | +| `concat()` | 返回两个或多个连接后的字符串 | +| `constructor` | 返回字符串的构造函数 | +| `endsWith()` | 检查字符串是否以指定值结尾 | +| `fromCharCode()` | 根据给定的 Unicode 值返回对应字符 | +| `includes()` | 检查字符串是否包含指定值 | +| `indexOf()` | 返回指定值第一次出现的索引 | +| `lastIndexOf()` | 返回指定值最后一次出现的索引 | +| `length` | 返回字符串的长度 | +| `localeCompare()` | 根据本地化规则比较两个字符串 | +| `match()` | 根据给定的值或正则表达式匹配字符串 | +| `prototype` | 用于给对象添加属性和方法 | +| `repeat()` | 返回由指定次数重复组成的新字符串 | +| `replace()` | 返回一个新字符串，其中的值根据正则表达式或指定值被替换 | +| `search()` | 根据字符串与给定值或正则表达式的匹配结果返回索引 | +| `slice()` | 返回包含部分原始内容的子字符串 | +| `split()` | 将字符串拆分为子字符串数组 | +| `startsWith()` | 检查字符串是否以指定字符或子串开头 | +| `substr()` | 从起始索引处提取部分字符串 | +| `substring()` | 在两个索引之间提取部分字符串 | +| `toLocalLowerCase()` | 根据主机的本地化设置，将字符串转换为小写并返回 | +| `toLocalUpperCase()` | 根据主机的本地化设置，将字符串转换为大写并返回 | +| `toLowerCase()` | 返回转换为小写形式的字符串 | +| `toString()` | 以字符串形式返回该值或字符串对象 | +| `toUpperCase()` | 返回转换为大写形式的字符串 | +| `trim()` | 返回删除首尾空白符后的字符串 | +| `trimEnd()` | 返回删除末尾空白符后的字符串 | +| `trimStart()` | 返回删除开头空白符后的字符串 | +| `valueOf()` | 返回字符串或字符串对象的原始值 | + + +在本章中，我们将探讨以下主题： +* [CharAt](./charAt.md) +* [Concat](./concat.md) +* [Create](./create.md) +* [Length](./length.md) +* [Replace](./replace.md) +* [Split](./split.md) +* [Substring](./substring.md) diff --git a/cn/strings/charAt.md b/cn/strings/charAt.md new file mode 100644 index 00000000..8fe9e150 --- /dev/null +++ b/cn/strings/charAt.md @@ -0,0 +1,53 @@ +--- +chapter: 4 +pageNumber: 37 +--- + +# CharAt + +`str.charAt()` 方法返回字符串中指定索引位置处的字符，该索引表示类似数组元素的位置。 +* 使用 `charAt()` 方法 +* 使用模板字符串 `(``)`（在 [ES6](../es6-concepts/template-literals.md) 中引入） + +`charAt()` 方法接收以下内容： + +* **arguments（参数）**：此函数唯一的参数是字符串中的索引位置，用于指定要提取的单个字符。 + +* **index（索引）**：该索引的取值范围是从 `0` 到 `length – 1`。如果未指定索引，则默认使用索引 `0`，返回字符串的第一个字符。 + +* **return value（返回值）**：返回位于函数参数所指定索引位置的单个字符。如果索引超出范围，则该函数返回空字符串。 + +```javascript +//Example 1: +function func() { + // 原始字符串 + let str = 'JavaScript is object oriented language'; + + // 查找给定索引处的字符 + let value = str.charAt(0); + let value1 = str.charAt(4); + console.log(value); + console.log(value1); +} +func(); + +//Output +j +s + +//Example 2: +function func() { + + // 原始字符串 + let str = 'JavaScript is object oriented language'; + + // 查找给定索引处的字符 + let value = str.charAt(9); + console.log(value); +} +func(); + + +//Output +t +``` \ No newline at end of file diff --git a/cn/strings/concat.md b/cn/strings/concat.md new file mode 100644 index 00000000..4463bdc5 --- /dev/null +++ b/cn/strings/concat.md @@ -0,0 +1,33 @@ +--- +chapter: 4 +pageNumber: 35 +--- + +# 拼接 + +拼接就是把两个或更多字符串连接在一起，生成一个更长的字符串，其中包含这些原始字符串的组合数据。字符串的拼接是将一个或多个字符串附加到另一个字符串后面。在 JavaScript 中，可以通过以下方式实现： + +* 使用 `+` 运算符 +* 使用 `concat()` 方法 +* 使用数组的 `join()` 方法 +* 使用模板字面量 `(``)`（在 [ES6](../es6-concepts/template-literals.md) 中引入） + +字符串的 `concat()` 方法接收一系列字符串作为参数，并在拼接后返回一个新字符串，即所有字符串的组合。相对地，数组的 `join()` 方法用于将数组中所有元素连接成一个单一的字符串。 + +模板字面量使用反引号 `(``)`，并提供了一种简单的方式来创建多行字符串并进行字符串插值。可以在反引号中使用带有 `$` 符号和花括号的表达式 `${expression}`。 + +```javascript +const icon = '👋'; +// 使用模板字符串 +`hi ${icon}`; + +// 使用 join() 方法 +['hi', icon].join(' '); + +// 使用 concat() 方法 +''.concat('hi ', icon); + +// 使用 + 运算符 +'hi ' + icon; +// hi 👋 +``` diff --git a/cn/strings/create.md b/cn/strings/create.md new file mode 100644 index 00000000..044389be --- /dev/null +++ b/cn/strings/create.md @@ -0,0 +1,65 @@ +--- +chapter: 4 +pageNumber: 32 +--- + +# 创建 + +字符串可以通过将文本放在单引号或双引号中来定义： + +```javascript +// 可以使用单引号 +let str = 'Our lovely string'; + +// 也可以使用双引号 +let otherStr = "Another nice string"; +``` + +在 Javascript 中，字符串可以包含 UTF-8 字符： + +``` +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"; +``` + +你也可以使用 `String` 构造函数来创建一个字符串对象： + +```javascript +const stringObject = new String('This is a string'); +``` + +然而，一般并不推荐使用 `String` 构造函数来创建字符串，因为这可能会导致对字符串原始值与字符串对象的混淆。通常更好的做法是使用字符串字面量来创建字符串。 + +你也可以使用模板字面量来创建字符串。模板字面量是用反引号 `(``)` 括起来的字符串，并且可以包含值的占位符。占位符使用 `` `${}` `` 语法来表示。 + +```javascript +const name = 'John'; +const message = `Hello, ${name}!`; +``` + +模板字面量还可以包含多行，并且可以在占位符中放入任意表达式。 + +{% hint style="working" %} +字符串不能被相减、相乘或相除。 +{% endhint %} + +{% exercise %} +使用模板字面量创建一个字符串，其中包含 `name` 和 `age` 的值。该字符串应满足以下格式："My name is John and I am 25 years old."。 + +{% initial %} +let name = "John"; +let age = 25; + +// My name is John and I am 25 years old. +let result = +{% solution %} +let name = "John"; +let age = 25; + +// My name is John and I am 25 years old. +let result = `My name is ${name} and I am ${age} years old.` + +{% validation %} +assert(result == "My name is John and I am 25 years old."); + +{% context %} +{% endexercise %} diff --git a/cn/strings/length.md b/cn/strings/length.md new file mode 100644 index 00000000..d06a365b --- /dev/null +++ b/cn/strings/length.md @@ -0,0 +1,27 @@ +--- +chapter: 4 +pageNumber: 34 +--- + +# 长度 + +在 JavaScript 中，使用 `.length` 属性就可以很容易地知道一个字符串中有多少个字符。`length` 属性返回字符串中的字符数，包括空格和特殊字符。 + +```javascript + +let size = "Our lovely string".length; +console.log(size); +// size: 17 + +let emptyStringSize = "".length +console.log(emptyStringSize); +// emptyStringSize: 0 + +```` + +空字符串的 `length` 属性是 `0`。 + +{% hint style="working" %} +`length` 属性是只读属性，因此你不能为它赋予新的值。 +{% endhint %} + diff --git a/cn/strings/replace.md b/cn/strings/replace.md new file mode 100644 index 00000000..7c26d188 --- /dev/null +++ b/cn/strings/replace.md @@ -0,0 +1,31 @@ +--- +chapter: 4 +pageNumber: 33 +--- + +# Replace + +`replace` 方法允许我们用一个字符串替换某个字符、单词或句子。例如： + +```javascript +let str = "Hello World!"; +let new_str = str.replace("Hello", "Hi"); + +console.log(new_str); + +// 结果：Hi World! +```` + +{% hint style="working" %} +要在所有匹配处进行替换，需要在 [正则表达式](../regular-expression.md) 中设置 `g` 修饰符。 +{% endhint %} + +它会在字符串中查找某个值或正则表达式，并返回一个替换了该值（或这些值）的新字符串。它不会改变原始字符串。我们来看一个全局且不区分大小写的替换示例。 + +```javascript +let text = "Mr Blue has a blue house and a blue car"; +let result = text.replace(/blue/gi, "red"); + +console.log(result); +// 结果：Mr red has a red house and a red car +``` diff --git a/cn/strings/split.md b/cn/strings/split.md new file mode 100644 index 00000000..34d3fff1 --- /dev/null +++ b/cn/strings/split.md @@ -0,0 +1,47 @@ +--- +chapter: 4 +pageNumber: 36 +--- + +# Split + +`split()` 方法会将字符串分割成若干子字符串，并以数组形式返回。 +* 使用 `split()` 方法 +* 使用模板字符串（在 ES6 中引入） + +`split()` 方法接收以下参数： + +* **separator（可选）**： 描述每次分割应在何处发生的模式（字符串或正则表达式）。 +* **limit（可选）**： 一个非负整数，用于限制要将给定字符串分割成多少部分。 + +```javascript +console.log("ABCDEF".split("")); // [ 'A', 'B', 'C', 'D', 'E', 'F' ] + +const text = "Java is awesome. Java is fun."; + +let pattern = "."; +let newText = text.split(pattern); +console.log(newText); // [ 'Java is awesome', ' Java is fun', '' ] + +let pattern1 = "."; +// 只将字符串最多分割成两部分 +let newText1 = text.split(pattern1, 2); +console.log(newText1); // [ 'Java is awesome', ' Java is fun' ] + +const text2 = "JavaScript ; Python ;C;C++"; +let pattern2 = ";"; +let newText2 = text2.split(pattern2); +console.log(newText2); // [ 'JavaScript ', ' Python ', 'C', 'C++' ] + +// 使用正则表达式 +let pattern3 = /\s*(?:;|$)\s*/; +let newText3 = text2.split(pattern3); +console.log(newText3); // [ 'JavaScript', 'Python', 'C', 'C++' ] + +// 输出 +[ 'A', 'B', 'C', 'D', 'E', 'F' ] +[ 'Java is awesome', ' Java is fun', '' ] +[ 'Java is awesome', ' Java is fun' ] +[ 'JavaScript ', ' Python ', 'C', 'C++' ] +[ 'JavaScript', 'Python', 'C', 'C++' ] +``` \ No newline at end of file diff --git a/cn/strings/substring.md b/cn/strings/substring.md new file mode 100644 index 00000000..f1fe5ef2 --- /dev/null +++ b/cn/strings/substring.md @@ -0,0 +1,59 @@ +--- +chapter: 4 +pageNumber: 38 +--- + +# 子字符串 + +`string.substring()` 是 JavaScript 中的内置函数，用于返回给定字符串从起始索引到结束索引之间的部分。索引从零 `(0)` 开始。 + +语法: + +`string.substring(StartIndex, EndIndex)` + +### 语法: + +* 使用 `str.substr(start , length)` +* 使用 `substr()` 方法 +* 使用模板字面量 `(``)`（在 [ES6](../es6-concepts/template-literals.md) 中引入） + +`substr()` 方法接收： + +* **参数**：这里的 StartIndex 和 EndIndex 描述要作为子字符串取出的那一部分字符串。其中 EndIndex 是可选的。 +* **返回值**：它返回一个新的字符串，该字符串是给定字符串的一部分。下面的 JavaScript 代码展示了 `string.substring()` 函数的工作方式： + +```javascript +// 示例 1： +// 用 JavaScript 演示 substr() 方法 + +const str = "GeeksforGeeks"; +const result = str.substring(8); +console.log(result); + + + +// 输出 +for +``` + +```javascript + +// 示例 2： +// 将字符串作为变量 +let string = "geeksforgeeks"; +a = string.substring(-1) +b = string.substring(2.5) +c = string.substring(2.9) + +// 打印作为新字符串的内容 +// 它们是给定字符串的一部分 +console.log(a); +console.log(b); +console.log(c); + + +// 输出 +geeksforgeeks +eksforgeeks +eksforgeeks +``` From 44e547bf5ccdfb640232fdd8dbfaac69e7123a58 Mon Sep 17 00:00:00 2001 From: Suman Kunwar Date: Mon, 1 Dec 2025 07:22:56 -0500 Subject: [PATCH 4/5] Apply suggestion from @Copilot Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- cn/strings/charAt.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cn/strings/charAt.md b/cn/strings/charAt.md index 8fe9e150..95d17d53 100644 --- a/cn/strings/charAt.md +++ b/cn/strings/charAt.md @@ -32,7 +32,7 @@ function func() { func(); //Output -j +J s //Example 2: From 097c8aadc843288084d2f06ca4ef67b7c9534258 Mon Sep 17 00:00:00 2001 From: Suman Kunwar Date: Mon, 1 Dec 2025 07:24:55 -0500 Subject: [PATCH 5/5] Apply suggestion from @Copilot Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- cn/strings/substring.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cn/strings/substring.md b/cn/strings/substring.md index f1fe5ef2..c44cb39d 100644 --- a/cn/strings/substring.md +++ b/cn/strings/substring.md @@ -33,7 +33,7 @@ console.log(result); // 输出 -for +Geeks ``` ```javascript