JavaScript基础

内容概述

这一讲主要讲JavaScript的基础知识，包括JavaScript书写位置、基本语法（标识符、注释、关键字与保留字、变量、数据类型、操作符和语句）、数组和函数。

教学目的

了解JavaScript主要特点和核心组成部分，理解ECMAScript和JavaScript的关系
掌握JavaScript的书写位置
掌握JavaScript基本语法（标识符、注释、操作符、语句）
掌握在JavaScript怎么定义变量，掌握基本数据类型和判断数据类型，理解数据类型转换
掌握在JavaScript定义数组和数组常用方法
掌握在JavaScript中函数的基本用法

具体内容

JavaScript简介：特点和核心组成部分
在HTML使用JavaScript
语言基础：区分大小写、标识符、注释、关键字和保留字、变量、数据类型、操作符、语句
数组：创建数组、数组索引、遍历数组、数组增删改查
函数：定义函数、参数和返回值

JavaScript简介

JavaScript，简称JS，是一种高级的、解释型或即时编译型的编程语言。它最初由网景公司（Netscape）的前端工程师布兰登·艾奇（Brendan Eich）于1995年为网景导航者（Netscape Navigator）浏览器设计并实现。JavaScript是网页开发中不可或缺的一部分，与HTML和CSS共同构建现代网页的交互性和动态功能。

主要特点：

动态类型语言：JavaScript是一种弱类型语言，变量的类型在运行时可以发生改变。
面向对象：支持面向对象的编程模式，允许创建对象和定义它们之间的交互。
事件驱动：能够响应用户的操作（如点击、输入等），适合构建交互式的Web应用。
跨平台：JavaScript代码可以在几乎所有的现代浏览器上运行，不受操作系统限制。
可扩展性：可以通过添加新的函数和属性来扩展其内置对象的功能。
多范式：支持多种编程范式，包括过程式、面向对象和函数式编程。

核心组成部分：

js组成部分

ECMAScript：JavaScript的核心，描述了语言的基本语法和数据类型，ECMAScript是一套标准，定义了一种语言的标准与具体实现无关
DOM（文档对象模型）：提供了对HTML和XML文档的编程接口，允许开发者通过JavaScript来操作网页内容。
BOM（浏览器对象模型）：提供了与浏览器进行交互的方法和接口，如控制浏览器窗口、获取浏览器分辨率等。

后续提到JS、JavaScript、ECMAScript可以理解是一个东西

JavaScript的书写位置

内联JavaScript，内联JavaScript代码直接写在HTML元素的onclick、onload等事件属性中

html

<input type="button" value="按钮" onclick="alert('Hello World')" />

写在script标签中放置在HTML文档的head或body部分，这种方式比内联JavaScript代码更易于管理和维护，因为它将JavaScript代码与HTML内容分离。

html

<!DOCTYPE html>
<html>
<head>
    <title>内部JavaScript示例</title>
    <script>
        console.log('Hello, JavaScript!');
    </script>
</head>
<body>

</body>
</html>

html

<!DOCTYPE html>
<html>
<head>
    <title>内部JavaScript示例</title>
</head>
<body>

<script>
    console.log('Hello, JavaScript!');
</script>
</body>
</html>

写在外部js文件中，在页面引入外部JavaScript代码被放置在独立的.js文件中，然后通过HTML文档的script标签的src属性引入。这种方式最有利于代码的复用和维护，因为你可以在不同的HTML页面中引入同一个JavaScript文件。

html

<!DOCTYPE html>
<html>
<head>
    <title>内部JavaScript示例</title>
</head>
<body>

<script src="main.js"></script>
</body>
</html>

语言基础

区分大小写

首先要知道的是，JavaScript 中一切都区分大小写。无论是变量、函数名还是操作符，都区分大小写。换句话说，变量 test 和变量 Test 是两个不同的变量。类似地，typeof 不能作为函数名，因为它是一个关键字（后面会介绍）。但 Typeof 是一个完全有效的函数名。

标识符

所谓标识符，就是变量、函数、属性或函数参数的名称。标识符可以由一或多个下列字符组成：

第一个字符必须是一个字母、下划线（_）或美元符号（$）
剩下的其他字符可以是字母、下划线、美元符号或数字

注释

单行注释

javascript

// console.log('hello')

多行注释

javascript

/*
console.log('hello')
console.log('hello')
 */

关键字与保留字

关键字
关键字是JavaScript语言中具有特定含义的单词，它们被用作JavaScript语法的一部分。这些关键字不能被用作变量名、函数名、属性名等标识符。JavaScript中的关键字包括：

text

break, case, catch, class, const, continue, debugger, default, delete, do, else,  
enum, export, extends, false, finally, for, function, if, import, in, instanceof,  
let, new, null, return, super, switch, this, throw, true, try, typeof, var, void,  
while, with, yield, async, await, static, interface, implements, package, private,  
protected, public, abstract, constructor, get, set, nullish, from, of, as, async,  
await, globalThis, symbol, bigint

保留字
保留字是JavaScript保留以供将来使用的单词。虽然它们目前可能不是关键字，但在JavaScript的未来版本中可能会被赋予特殊含义。因此，也不应将这些单词用作变量名、函数名等标识符。JavaScript的保留字包括：

text

class, enum, extends, super, const, export, import, let, yield, implements,  
interface, package, private, protected, public, static, get, set, async, await

请注意，随着JavaScript语言的发展，新的关键字和保留字可能会被添加到语言中。

定义变量

JavaScript变量是松散类型的，意思是变量可以用于保存任何类型的数据。每个变量只不过是一个用于保存任意值的命名占位符。有 3 个关键字可以声明变量：var、const 和 let。其中，var 在 ECMAScript 的所有版本中都可以使用，而 const 和 let 只能在 ECMAScript 6 及更晚的版本中使用。

var

var是JavaScript中最早用于定义变量的关键字。使用var定义的变量具有函数作用域或全局作用域（如果在函数外部定义）。var声明的变量存在变量提升现象，即无论变量在何处声明，都会被视为在函数或全局作用域的最顶部声明。

函数作用域

javascript

function test () {
  var a = 1
  console.log(a); // 1
}

console.log(a); // 报错

全局作用域

javascript

for (var i = 0; i <= 10; i++) {
  console.log(i);
}
console.log(i); // 11

变量提升

javascript

console.log(a); // 不报错，打印undefined
var a = 1;

相当于这样写，但是不建议这样做

javascript

var a;
console.log(a); // 不报错，打印undefined
a = 1;

let

let是ES6（ECMAScript 2015）中引入的关键字，用于定义块级作用域的局部变量。与var不同，let声明的变量不会进行变量提升，且只能在声明它们的块或子块中被访问。

块级作用域

javascript

for (let i = 0; i <= 10; i++) {
  console.log(i);
}
console.log(i); // 报错

不会变量提升

javascript

console.log(a); // 报错 暂时性死区
let a = 1;

const

const也是ES6中引入的关键字，用于定义常量，即其值在初始化后不能被重新赋值的变量。const声明的变量也拥有块级作用域，并且同样不会进行变量提升。

不能重复赋值

javascript

const a = 1;
a = 2; // 报错

在大多数情况下，推荐使用let和const，因为它们提供了更清晰的作用域控制和更安全的编程方式。

数据类型

JavaScript 是一种动态类型语言，这意味着您不需要在声明变量时指定其类型。JavaScript 会根据赋值自动确定变量的类型。然而，了解 JavaScript 支持的数据类型对于编写有效和高效的代码至关重要。JavaScript 中的数据类型主要分为两大类：原始数据类型和对象数据类型。

javascript

var a = 1
a = 'hello' // 可以将变量赋值成任何类型

原始数据类型

Undefined

Undefined 类型只有一个值，就是特殊值 undefined。当使用 var 或 let 声明了变量但没有初始化时，就相当于给变量赋予了 undefined 值

javascript

let a;
console.log(a); // undefined

注意undefined和未定义变量是有区别的

javascript

let a;
console.log(a); // undefined
console.log(b); // 报错

Null

Null 类型同样只有一个值，即特殊值 null，表示一个空值，在定义将来要保存对象值的变量时，建议使用 null 来初始化

Boolean

表示逻辑值，true 或 false。

Number

表示数字，可以是整数或浮点数，还可以表示 NaN（Not-a-Number）和无穷大（Infinity）。

NaN

意思是“不是数值”（Not a Number），用于表示本来要返回数值的操作失败了（而不是抛出错误）。比如，用字符串乘任意数值

javascript

let num = "abc" * 10
console.log(num); // NaN

String String（字符串）数据类型表示零或多个 16 位 Unicode 字符序列。字符串可以使用双引号（"）、单引号（'）或反引号（`）标示，因此下面的代码都是合法的：

javascript

let str1 = "abc"
let str2 = 'abc'
let str3 = `abc`

转义字符

在JavaScript中，字符的转义（或称转移）通常用于在字符串中表示那些无法直接输入或具有特殊含义的字符。转义字符以反斜杠（\）开始，后跟一个或多个字符来表示一个特定的字符或字符序列。下面是一些常见的转义字符及其用途：

\n：换行符。在字符串中插入一个新行。
\t：水平制表符（Tab）。在字符串中插入一个制表符，通常用于对齐文本。
\：反斜杠字符本身。因为反斜杠是转义字符的引导符，所以如果你想在字符串中表示一个反斜杠，你需要使用两个反斜杠（\）。
'：单引号字符。在定义单引号包围的字符串时，使用它来包含单引号字符。
"：双引号字符。在定义双引号包围的字符串时，使用它来包含双引号字符。
\r：回车符。在不同的操作系统中，\r 的行为可能有所不同，但通常与 \n 一起使用（\r\n）来表示一个换行符。
\uXXXX：Unicode字符。其中 XXXX 是四位十六进制数，表示一个Unicode字符。这允许你在字符串中包含几乎任何字符，包括那些无法在键盘上直接输入的字符。
\xXX：十六进制转义序列。其中 XX 是两位十六进制数，用于表示ASCII字符集中的字符。这不是在ES6及以后版本中推荐用于Unicode字符的方法，但可用于表示ASCII字符。
\v：垂直制表符。它用于在文本中创建垂直的空白区域，但不如 \t 常用。
\f：换页符。在打印文档时，它指示打印机移动到下一页的开始位置。
\0：空字符（null字符）。它通常用于字符串的末尾，但在JavaScript中，字符串的末尾由字符串的结束自动表示，不需要显式地添加 \0。

BigInt

用于表示大于 2^53 - 1 的整数

Symbol

表示唯一不可变的

对象数据类型

对象数据类型，也称为引用类型，包括：

Object：是所有对象的基础，对象可以包含多个名为属性的值。
Array：一种特殊的对象，用于存储有序集合的值。数组的每个元素可以通过索引（即位置）来访问。
Function：可执行的代码块，并计算出一个值。函数还可以被当作值来赋值给变量。
Date：用于处理日期和时间的对象。
RegExp：用于定义字符串的搜索模式的对象。
其他内置对象：如 Math（数学对象）、Global（全局对象，在浏览器中是 window）、Error（错误对象）等。

数据类型转换

转换为Boolean类型

布尔类型转换是一个常见的操作，它允许你将不同类型的值转换为布尔类型（true 或 false）。这种转换通常发生在逻辑操作（如 if 语句、逻辑运算符等）中，当JavaScript需要判断一个值是否为真时。

以下是一些基本的布尔类型转换规则：

字符串String: 非空字符转换为true，空字符转换为false
数字Number: 非零转换为true，零转换为false
对象Object: 任意对象转换为true，null转换为false
Undefined: 转换为false

javascript

if ("") {  
  console.log("This will not run.");  
}  
  
if ("hello") {  
  console.log("This will run because 'hello' is truthy.");  
}  
  
if (0) {  
  console.log("This will not run because 0 is falsy.");  
}  
  
if (1) {  
  console.log("This will run because 1 is truthy.");  
}  
  
if (null) {  
  console.log("This will not run because null is falsy.");  
}  
  
if (undefined) {  
  console.log("This will not run because undefined is falsy.");  
}  
  
if ({}) {  
  console.log("This will run because objects are truthy.");  
}  
  
if ([]) {  
  console.log("This will run because arrays are truthy.");  
}

可能需要显式地使用 Boolean() 函数或逻辑非运算符（!）来将值转换为布尔类型，以确保代码的清晰性和准确性。

javascript

let myValue = "something";  
if (Boolean(myValue)) {  
  console.log("myValue is truthy.");  
}  
  
// 或者使用逻辑非运算符  
if (!!"anotherValue") {  
  console.log("anotherValue is truthy.");  
}

数值转换

JavaScript 中的数值转换涉及将值从一种类型转换为数值类型。这通常是为了进行数学计算或比较。JavaScript 提供了几种不同的方式来实现数值转换：

使用 Number() 函数 Number() 函数是转换数据类型到数值的最直接方法。它可以处理多种类型的输入：

字符串：如果字符串可以被解析为一个数值，它将被转换为相应的数值。否则，结果为 NaN（不是一个数值）。
布尔值：true 转换为 1，false 转换为 0。
null：转换为 0。
undefined：转换为 NaN。

javascript

Number("123")     // 123  
Number("12.3")    // 12.3  
Number("12.3.4")  // NaN  
Number("123abc")  // NaN  
Number(true)      // 1  
Number(false)     // 0  
Number(null)      // 0  
Number(undefined) // NaN

使用一元加运算符 +

一元加运算符尝试将其操作数转换为数值（类似于 Number() 函数）：

javascript

+"123"     // 123  
+"12.3"    // 12.3  
+"abc"     // NaN  
+true      // 1  
+false     // 0  
+null      // 0  
+undefined // NaN

使用 parseInt() 和 parseFloat() 函数

这两个函数专门用于解析字符串，并尝试将其转换为整数或浮点数。parseInt() 还可以解析以 0x 或 0X 开头的十六进制数，以及以 0b 或 0B 开头的二进制数，和以 0o 或 0O 开头的八进制数。

javascript

console.log(parseInt("123"));    // 123  
console.log(parseInt("12.3"));    // 12  
console.log(parseInt("abc"));     // NaN  
console.log(parseInt("123abc"));  // 123  
console.log(parseFloat("123"));   // 123  
console.log(parseFloat("12.3"));  // 12.3  
console.log(parseFloat("12.3.4")); // 12.3

隐式转换在某些情况下，JavaScript 会自动尝试将值转换为数值，特别是在涉及数学运算符（如 +、-、*、/）时：

javascript

"5" * "2"   // 10  
"5" - 2     // 3  
"5" + 2     // "52" 注意这里是字符串连接

typeof操作符

typeof 操作符在 JavaScript 中是一个一元操作符，用来返回一个字符串，表示未经计算的操作数的类型。使用 typeof 可以帮助我们判断一个变量或值是不是字符串、布尔值、数字、对象、函数、undefined 或 symbol。

javascript

console.log(typeof "Hello world"); // "string"  
console.log(typeof 42);            // "number"  
console.log(typeof true);          // "boolean"  
console.log(typeof undefined);     // "undefined"  
console.log(typeof null);          // "object" （这是一个长期存在的错误）  
console.log(typeof {name: "John"});// "object"  
console.log(typeof [1, 2, 3]);     // "object" （数组也是对象）  
console.log(typeof function(){});  // "function"  
console.log(typeof Symbol('id'));  // "symbol"

null 的类型：尽管 null 是表示“无”的对象，使用 typeof 检查 null 会返回 "object"，这是一个历史遗留的问题。
数组和对象：typeof 对于数组和对象都返回 "object"，这意味着你需要使用其他方式（如 Array.isArray()）来检查一个对象是否是数组。
typeof 不是一个函数：尽管它看起来像是函数调用，typeof 实际上是一个操作符，因此你不需要（也不能）在其后加括号，除非你在检查一个表达式的类型。

操作符

赋值操作符：

=：将右侧的值赋给左侧的变量。
+=、-=、*=、/=：在赋值之前进行算术运算。

算术操作符

+、-、*、/：基本的加、减、乘、除运算。
%：取模（余数）运算。
++、--：递增和递减操作符。

字符串操作符

+：用于连接两个字符串值。

比较操作符

等于（==）：比较两个值是否相等，但在比较之前会进行类型转换。
严格等于（===）：比较两个值是否严格相等，不会进行类型转换。
不等于（!=）：比较两个值是否不相等，但在比较之前会进行类型转换。
严格不等于（!==）：比较两个值是否严格不相等，不会进行类型转换。
大于（>）、小于（<）、大于等于（>=）、小于等于（<=）：用于比较两个数值或字符串的大小。

逻辑操作符

逻辑与（&&）：如果两个操作数都为真，则条件为真。
逻辑或（||）：如果两个操作数中至少有一个为真，则条件为真。
逻辑非（!）：用于反转操作数的布尔值。

条件（三元）操作符

条件（三元）操作符（? :）：它是 JavaScript 中唯一的三元操作符，用于基于条件来返回两个值之一。

位操作符

位与（&）、位或（|）、位异或（^）、位非（~）、左移（<<）、有符号右移（>>）、无符号右移（>>>）：这些操作符用于对数字的二进制表示进行位级别的操作。

语句

条件语句

if...else：根据条件表达式的真假来执行不同的代码块。还可以使用 else if 来添加更多的条件分支。

javascript

if (i > 25) {
  console.log("Greater than 25.");
} else if (i < 0) {
  console.log("Less than 0.");
} else {
  console.log("Between 0 and 25, inclusive.");
}

switch：根据表达式的值选择多个代码块之一来执行。

javascript

switch (expression) {  
  case value1:  
    // 当 expression 等于 value1 时执行的代码  
    break;  
  case value2:  
    // 当 expression 等于 value2 时执行的代码  
    break;  
  // ...  
  default:  
    // 当没有任何 case 匹配时执行的代码  
}

循环语句

for：在给定条件为真时，重复执行一段代码块，并在每次循环结束时更新条件。

javascript

for (initialization; condition; final-expression) {  
  // 循环体  
}

// 从1打印到100
for (let i = 1; i <= 100; i++) {
    console.log(i);
}

while：当条件为真时，重复执行一段代码块。

javascript

while (condition) {  
  // 循环体  
}
// 从1打印到100
let i = 1
while(i < = 100) {
    console.log(i);
    i++;
}

do...while：至少执行一次代码块，然后只要条件为真就重复执行。

javascript

do {  
  // 循环体  
} while (condition);

// 从1打印到100
let i = 1
do {
	console.log(i);
    i++
} while(i < = 100)

跳转

break：用于完全结束最近的循环或 switch 语句

javascript

for (let i = 0; i < 10; i++) {  
  if (i === 5) {  
    break; // 跳出循环  
  }  
  console.log(i);  
}

continue：跳过循环中当前迭代的剩余部分，并继续下一次迭代。

javascript

for (let i = 0; i < 10; i++) {  
  if (i % 2 === 0) {  
    continue; // 跳过偶数  
  }  
  console.log(i);  
}

label（与 break 或 continue 一起使用）：为循环或代码块指定一个标识符（标签），允许 break 或 continue 语句跳转到该标签处。

javascript

outerLoop:
  for (let i = 0; i < 3; i++) {
    innerLoop:
      for (let j = 0; j < 3; j++) {
        console.log(`i = ${i}, j = ${j}`);
        if (i === 1 && j === 1) {
          break outerLoop; // 跳出外层循环
        }
      }
  }

数组

创建数组

使用数组字面量

这是最直接和常用的方法，使用方括号[]来包含数组的元素。

javascript

let fruits = ['苹果', '香蕉', '梨'];

使用Array构造函数

你可以使用Array构造函数来创建一个新数组。这个方法可以传递一个数字作为参数来指定数组的长度，但是需要注意的是，通过这种方式创建的数组，其元素都是undefined。

javascript

let numbers = new Array(3); // 创建一个包含3个undefined的数组  
console.log(numbers); // 输出: [undefined, undefined, undefined]  
  
// 或者直接初始化元素  
let colors = new Array('Red', 'Green', 'Blue');

数组索引

在JavaScript中，数组是一种使用索引来访问其元素的数据结构。数组的索引是整数值，用于指定元素在数组中的位置。在JavaScript中，数组索引从0开始，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。

访问数组元素

可以通过指定索引来访问数组中的元素。如果索引超出了数组的范围（即小于0或大于等于数组的长度），则返回undefined。

javascript

let fruits = ['Apple', 'Banana', 'Cherry'];  
console.log(fruits[0]); // 输出: Apple  
console.log(fruits[1]); // 输出: Banana  
console.log(fruits[2]); // 输出: Cherry  
console.log(fruits[3]); // 输出: undefined，因为索引3超出了数组范围

修改数组元素

可以通过指定索引来修改数组中的元素。

javascript

let numbers = [1, 2, 3];  
numbers[1] = 20; // 修改索引为1的元素  
console.log(numbers); // 输出: [1, 20, 3]

数组长度

数组的length属性表示数组中元素的数量。通过修改length属性，你可以添加或删除数组中的元素。

如果将length设置为一个比当前长度小的值，则超出新长度的元素将被删除。
如果将length设置为一个比当前长度大的值，则数组将增加新的空位（undefined值）。

javascript

let numbers = [1, 2, 3];  
numbers.length = 2; // 删除索引为2的元素  
console.log(numbers); // 输出: [1, 2]  
  
numbers.length = 5; // 增加数组长度，新增的索引为3和4的元素为undefined  
console.log(numbers); // 输出: [1, 2, undefined, undefined, undefined]

负数索引和非整数索引

需要注意的是，虽然JavaScript允许你使用非整数（如浮点数或字符串）作为索引来访问数组元素，但这样的索引会被转换为字符串，并作为对象的属性名来处理，而不是作为数组的索引。因此，它们不会影响到数组的length属性，也不会被forEach、map等数组方法遍历。

javascript

let arr = [];  
arr['2.5'] = 'Hello';  
arr['foo'] = 'World';  
  
console.log(arr.length); // 输出: 0，因为没有使用整数索引  
console.log(arr[2.5]); // 输出: Hello，因为索引被当作字符串处理  
console.log(arr['2.5']); // 输出: Hello  
console.log(arr['foo']); // 输出: World

然而，这种用法并不推荐，因为它会导致代码难以理解和维护。最好坚持使用整数索引来访问和操作数组元素。

遍历数组

通过for循环

javascript

let arr = [1, 2, 3];  
for (let i = 0; i< arr.length; i++) {
    console.log(arr[i])
}

通过for of循环

javascript

let arr = [1, 2, 3];  
for (let item of arr) {
    console.log(item)
}

通过数组的迭代方法 forEach、map、filter等

javascript

arr.forEach(function (item){
    console.log(item)
})

数组增删改查

增加元素

push()

向数组的末尾添加一个或多个元素，并返回新的长度。

javascript

let arr = [1, 2, 3];  
arr.push(4, 5);  
console.log(arr); // 输出: [1, 2, 3, 4, 5]

unshift()

向数组的开头添加一个或多个元素，并返回新的长度。

javascript

let arr = [1, 2, 3];  
arr.unshift(0);  
console.log(arr); // 输出: [0, 1, 2, 3]

splice()

从指令位置插入一个或多个元素

javascript

let arr = [1, 2, 3, 4, 5]; 
arr.splice(2, 0, 'a', 'b'); // 从索引2开始添加'a'和'b'  
console.log(arr); // 输出: [1, 2, 'a', 'b', 3, 4, 5]

删除元素

pop()

删除并返回数组的最后一个元素。

javascript

let arr = [1, 2, 3];  
let last = arr.pop();  
console.log(arr); // 输出: [1, 2]  
console.log(last); // 输出: 3

shift()

删除并返回数组的第一个元素。

javascript

let arr = [1, 2, 3];  
let first = arr.shift();  
console.log(arr); // 输出: [2, 3]  
console.log(first); // 输出: 1

修改元素

直接通过数组索引进行修改

查找元素

直接遍历数组

javascript

let arr = [1, 2, 3];
let index = -1;
for (let i = 0; i< arr.length; i++) {
    if (arr[i] === 2) {
        index = i;
        break;
    }
}

indexOf()

返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

javascript

let arr = [2, 5, 9];  
console.log(arr.indexOf(2)); // 输出: 0  
console.log(arr.indexOf(7)); // 输出: -1

函数

JavaScript 中的函数是执行特定任务的代码块。你可以将函数视为一个“黑盒”，它接受输入（称为参数），执行一系列的操作，然后可能返回一个输出（称为返回值）。函数在JavaScript中非常重要，它们不仅用于封装代码以提高可读性和可重用性，还是实现模块化编程和面向对象编程的基础。

定义函数

在JavaScript中，你可以使用多种方式来定义函数。

函数声明

javascript

function functionName(parameters) {  
  // 函数体  
}  
  
function greet(name) {  
  console.log("Hello, " + name + "!");  
}  
  
greet("World"); // 输出: Hello, World!

函数表达式

函数表达式可以存储在变量中或作为参数传递给其他函数，也可以作为其他函数的返回值。

javascript

const greet = function(name) {  
  console.log("Hello, " + name + "!");  
};  
  
greet("World"); // 输出: Hello, World!

参数和返回值

参数：函数定义时括号内的变量。这些变量在函数被调用时会被赋予具体的值。
返回值：函数执行完成后，可以使用return语句返回一个值。如果函数没有return语句，它将返回undefined。

javascript

function sum(a, b) {  
  return a + b;  
}  
  
const result = sum(5, 3);  
console.log(result); // 输出: 8

作业

实现函数，函数接收一个参数arg，类型未知，如果是数字返回该数字的平方，如果是字符串将该字符串重复5次并返回，如果是其他类型直接返回该参数

javascript

function test1(arg) {
  // 补充代码
}

console.log(test1(10)); // 100
console.log(test1('abc')); // 'abcabcabcabcabc'

实现函数，函数接收一个数组且每个元素都是数字，分别计算数组的最小值、最大值、平均值按顺序放入一个长度为3的数组中并返回

javascript

function test2(arr) {
  // 补充代码
}

console.log(test2([1, 7, 10])); // [1, 10, 6]

JavaScript基础 ​

内容概述 ​

教学目的 ​

具体内容 ​

JavaScript简介 ​

主要特点： ​

核心组成部分： ​

JavaScript的书写位置 ​

语言基础 ​

区分大小写 ​

标识符 ​

注释 ​

关键字与保留字 ​

定义变量 ​

var ​

let ​

const ​

数据类型 ​

原始数据类型 ​

对象数据类型 ​

数据类型转换 ​

typeof操作符 ​

操作符 ​

赋值操作符： ​

算术操作符 ​

字符串操作符 ​

比较操作符 ​

逻辑操作符 ​

条件（三元）操作符 ​

位操作符 ​

语句 ​

条件语句 ​

循环语句 ​

跳转 ​

数组 ​

创建数组 ​

数组索引 ​

访问数组元素 ​

修改数组元素 ​

数组长度 ​

负数索引和非整数索引 ​

遍历数组 ​

数组增删改查 ​

增加元素 ​

删除元素 ​

修改元素 ​

查找元素 ​

函数 ​

定义函数 ​

函数声明 ​

函数表达式 ​

参数和返回值 ​

作业 ​

JavaScript基础

内容概述

教学目的

具体内容

JavaScript简介

主要特点：

核心组成部分：

JavaScript的书写位置

语言基础

区分大小写

标识符

注释

关键字与保留字

定义变量

var

let

const

数据类型

原始数据类型

对象数据类型

数据类型转换

typeof操作符

操作符

赋值操作符：

算术操作符

字符串操作符

比较操作符

逻辑操作符

条件（三元）操作符

位操作符

语句

条件语句

循环语句

跳转

数组

创建数组

数组索引

访问数组元素

修改数组元素

数组长度

负数索引和非整数索引

遍历数组

数组增删改查

增加元素

删除元素

修改元素

查找元素

函数

定义函数

函数声明

函数表达式

参数和返回值

作业