关于注释

• 默认的单行注释快捷键：ctrl+/
• 默认的多行注释和取消注释 快捷键都是shift+Alt+a
• 默认的快捷键不是很方便，可以自己需要修改一下。改成ctrl+shift+/.(你要是不喜欢也可以不改)

js客户端的脚本语言

逐行解释。渲染引擎俗称内核

js组成

关于注释

• 默认的单行注释快捷键：ctrl+/
• 默认的多行注释和取消注释 快捷键都是shift+Alt+a
• 默认的快捷键不是很方便，可以自己需要修改一下。改成ctrl+shift+/.(你要是不喜欢也可以不改)

JavaScript输入输出语句

• alert(msg) 浏览器弹出警示框
• console.log(msg)浏览器控制台打印输出信息
• prompt（info）浏览器弹出输入框。用户可以输入

1.变量概述

1.1什么是变量

变量是用于存储数据的容器。本质是内存的一块空间。

一个变量应该有一个空间还有一个变量名用来找到这个空间。

1.2变量的使用

变量的使用分两步，第一步是声明变量，第二赋值。

var age;//声明一个名称为age的变量。

• var 是一个JS的关键字，用来声明变量。使用该关键字声明变量后，计算机会自动为变量分配内存空间，不需要程序员管。
• age是程序员定义 的变量名，我们要通过变量名来访问内存中分配的空间。
• 赋值 = ；这不是等于号，是给的意思。用来把右边的值赋给左边的变量空间中，此处代表赋值的意思。
• 变量值是程序员保存到变量空间的值。

声明变量如下

var myname='pink';

意思是声明了一个名为myname的变量同时把pink赋值给这个名为myname的变量。

• 声明变量也叫变量初始化。
• 可以同时声明多个变量，用逗号隔开。
• 只声明不赋值，程序结果是underfined 未定义。
• 不声明不赋值，直接使用某个变量会报错的。
• 不声明，直接赋值使用，可以使用。（会变成全局变量）

变量名的命名规范

• 严格区分大小写。
• 由字母(A-Z a-z)、数字(0-9)、下划线（_）、美元符号$组成。如：usrAge,num01,_name
• 不能以数字开头。
• 不能是关键词，保留字。如：var\for\while
• 变量名必须由意义。
• 遵守驼峰命名法。首字母小写，后面单词的首字母需要大写。myFirstName
• 推荐翻译网站：有道，爱词霸。

//交换两个变量的值。

        var temp;

        var apple1 = '青苹果';

        var apple2 = '红苹果';

        console.log(apple1, apple2);

        temp = apple1;

        apple1 = apple2;

        apple2 = temp;

        console.log(apple1, apple2);

JS的变量数据类型是只有程序在运行过程中，根据=右边的数据类型来判断的。运行完毕之后，变量就确定了数据类型。JavaScript拥有动态类型，同时也意味着相同的变量可用做不同的类型。

如：var x = 6; var x = "Bill";前面是X为数字，后面X为字符串。

Js是动态语言，变量的数据类型是可以变化的。

2.简单数据类型

• Number 数字型，包含整数型和浮点型值，如21、0.21 默认值是0
• Boolean 布尔值类型，如true,false,等价于1和0，默认值false
• String字符串型，如“张三”注意js里面，字符串都带引号“”
• Undefined var a ;声明了a变量但是没有给值，此时a=Undefined。默认值Underfined
• Null var a =null；声明了变a为空值。默认值是null

JS的变量数据类型是只有程序在运行过程中，根据=右边的数据类型来判断的。运行完毕之后，变量就确定了数据类型。JavaScript拥有动态类型，同时也意味着相同的变量可用做不同的类型。

如：var x = 6; var x = "Bill";前面是X为数字，后面X为字符串。

Js是动态语言，变量的数据类型是可以变化的。

2.2数字型Number

最常见的进制有二进制、八进制、十进制、十六进制。

• 八进制数字序列范文：0~7；程序里面数字前面加0表示八进制。逢八进一。
• 十六进制 0~9 a~f ；
• 现阶段只要记住在JS中八进制前面加0，十六进制前面加0x

数值型的三个特殊值

• infinity 代表无穷大，大于任何数值
• -Infinity 代表无穷小，小于任何数值
• NaN，Not a number,代表一个非数值

console.log(Number.MAX_VALUE);最大

console.log(Number.MIN_VALUE);最小

isNaN()这个方法用来判断是不也是非数字，并返回一个值。如果是数字返回的是false如果不是数字返回的是true。

console.log(isNaN('hong'));/*结果是一true*/

console.log(isNaN(12));/*结果是false*/

2.3字符串型String

字符串型可以是引号中的任意文本，其语法为双引号“”和单引号’‘

字符串是有嵌套的情况。JS可以用单引号嵌套双引号，或者双引号嵌套单引号（外双内单，外单内双）

字符串转义符

类似Html里面的特殊字符，字符串也有特殊字符，我们称之为转义符。转义符都是\开头的，嵌套时候记得要写在引号里面。常用的转义符有一下：

\n 换行符，n是newline的意思

\\ 斜杠\

\’ 单引号‘

\" 双引号”

\t tab缩进

\b 空格，b是blank的意思

（1）字符串长度length属性可以获取字符串的长度。

  console.log(str.length);

字符串的拼接

（2）多个字符串之间用+号拼接。字符串型拼接后数据类型都是字符型。数值相加，字符相连。

        var age = prompt('你知道我多大了吗？');

        var str = '你今年已经' + age + '岁了';

        alert(str);

布尔型Boolean

布尔型有两个值：true和false,其中true表示真（对），而false表示假（错）。

true参与加法运算当1来看，false参与运算当0来看。

Undefined和Null

一个声明后没有被赋值的变量会有一个默认值undefined（如果进行相连或者相加时，注意结果）

undefined和字符相连得到字符

undefined和数字相加得NaN。

null空值。null和字符相连得到字符，和数字相加得数字。

3.获取变量数据类型

获取检测变量的数据类型

typeof可以用来获取检测变量的数据类型.

prompt取过来的值是字符型的。

浏览器检测也能看数据类型。黑色是字符串型的，紫色是数值型的，深蓝色是布尔型的。

字面量

字面量是在源代码中一个固定值的表示法，通俗来说就是字面量表示如何表达这个值。

• 数字字面量：8、9、10
• 字符串字面量：”我们是人才“
• 布尔字面量：true,false

4.数据类型转换

把一种数据类型的变量转换成另一种数据类型。

（1）转换为字符串3种方法

• to String() 转换成字符串
• String()强制转换
• 拼接转换

加号拼接字符串 和字符串拼接的结果都是字符串。

三种转换方式，更喜欢第三种加号拼接字符串转换方式，这一种方式也称之为隐式转换

（2）转换为数字型（重点）

• parseInt(变量)；可以把字符型转换为数字型，的到的是整数。

 console.log(parseInt('1.366'))//得到1.会取整。

console.log(parseInt('120px'));//得到的是120，因为会取整，同时也会去掉单位。

• parseFloat（）把字符转换为浮点数数值型 如 console.log(parseFloat('3.2569'));得到3.2569，会保留小数点后面的数字。console.log(parseFloat('130px'));//得到的是130，也会去掉单位

  console.log(parseFloat('rem165px'));//得到NaN  空

• Number()强制转换函数，将字符串型转换为数值型，Number('12');

  console.log(Number('569'));//得到数字型的569

        console.log(Number('16px'));//得到NaN  空

• js隐式转换（-*/）利用算术运算隐式转换为数值型如：‘12’-0

<script>
        var num = 10;
        //var str = num.toString();

        console.log(num);
        //console.log(typeof str);
        console.log(String(num));
        console.log(typeof num);
        var age = prompt('请输入您的年龄');
        console.log(parseInt(age));
        console.log(parseInt('1.366'))//得到1.会取整。
        console.log(parseInt('120px'));//得到的是120，因为会取整，同时也会去掉单位。
        console.log(parseFloat('3.2569'));//得到3.2569，会保留小数点后面的数字。
        console.log(parseFloat('130px'));//得到的是130，也会去掉单位
        console.log(parseFloat('rem165px'));
        console.log(Number('569'));
        console.log(Number('16px'));//得到NaN  空

注意

parseInt和parseFloat 单词的大小写，这2个是重点

隐式转换是我们在进行算数运算的时候，JS自动转换为数据类型。

案例

计算年龄

   <script>
        //弹出一个输入框（prompt），让用户输入出生年份（用户输入）
        //把用户输入的值用变量保存起来，然后用今年的年份减去变量值，结果就是现在的年龄
        //弹出警示框（alert）,把计算的结果输出。

        var year = prompt('请输入您的出生年分');
        var age = 2022 - year;//year是字符型但是这里用减法有隐式转换
        alert('您今年已经' + age + '岁了');
    </script>

简单加法

思路是先输入一个加数，再输入一个加数，然后两个数相加，在输出结果。每一个数都要声明一个变量来保存它。因为prompt得到的是一个字符串，所以转变数值型。因为输入的数字有可能是带有小数点的。所以用了parseFloat（）

<script>
    var Addend1 = prompt('请输入第一个加数');
    var Addend2 = prompt('请输入第二个加数');
    var And = parseFloat(Addend1) + parseFloat(Addend2);
    alert('他们的和为' + And);
</script>

（3）转换为布尔型

Boolean()函数，其他类型转换成布尔值。案例 Boolean('true');

• 代表空，否定的值会被转换成false，如‘’、0、NaN、null、undefined
• 其余值都被转换为true

解释型语言和编程型语言

计算机不能直接理解任何除机器语言以外的语言，所以必须把程序员所写的程序语言翻译成机器语言才能执行程序，程序语言翻译成机器语言的工具成为翻译器

翻译器翻译的方式有两种：一种是编译，另一种是解释。两种方式之间的区别在于翻译的时间点不同。

• 编译器是在代码执行之前进行编译，生成中间代码文件（Java语言就是）
• 解释器是在运行时进行及时解释，并立即执行（当编译器以解释方式运行的时候，也称之为解释器），JS就是解释型语言

 案例作业

弹窗获取用户姓名性别年龄

 JavaScript运算符

运算符也被称作操作符，是用于实线赋值，比较和执行算数运算等功能的符号

算数运算符

加（+）、减（-）、乘（*）、除（/）、取余（%）

浮点数 算数运算里面会有问题，尽力避免直接小数去运算，后面会有办法。如下面：

console.log(0.1+0.2);//0.30000000000000004

console.log(0.07*100);//7.000000000000001

不能直接拿浮点数来进行相比较是否相等。

  var num = 0.1 + 0.3;

        console.log(num == 0.3);//false

问：我们怎么判断一个数能不能够被整除呢？

答：它的余数是0就说明这个数能被整除，这就是%取余运算符的主要用途。

问：请问1+2*3结果是？

答：7.算数运算符有优先级的，先乘除后加减，有小括号先算小括号里面的。

表达式和返回值

由数字、运算符、变量等组成的式子就是表达式如1+1；

表达式最终会有一个结果返回给我们，我们称之为返回值。

程序里的书写是这样的： 2=1+1 把右边的表达式计算完毕把返回值给左边。

var num=1+1;

递增和递减运算符

如果需要反复给数字变量添加或者减去1，可以使用递增（++）和递减（--）运算符来完成。

在js中递增++和递减--既可以放在变量前面也可以放在变量后面，放在变量前面时，我们称之为前置递增（递减）运算符，放在变量后面时，我们称之为后置递增（递减）运算符；

注意：递增和递减运算符必须和变量配合使用。

++num前置递增，就是自加1，类似于num=num+1,但是++num写起来更简单。口诀"先自加1.再返回值。"

 

num++后置递增。

前置自增和后置自增如果单独使用效果是一样的，

后置自增口诀："先返回原值后自加1"

总结

• 前置递增和后置递增运算符可以简化代码编写，让变量的值+1比以前写法更简单
• 单独使用时，运行结果相同
• 与其他代码连用时候执行结果不同
• 后置：先原值运算后自加（先人后己）
• 前置：先自加后运算（先己后人）
• 开发时大多数用后置递增/递减，并且代码独占一行。如：num++;num--

比较运算符

比较运算符（关系运算符）是两个数据进行比较时所使用的运算符，比较运算后会返回一个布尔值（true/false）作为比较运算的结果。

< 小于

> 大于

>= 大于等于（大于或者等于）

<= 大于等于 （小于或者等于）

== 判等号（会转型）

!= 不等号

=== !== 全等号 要求值和数据类型都一致。

console.log(3 === 5);//false

  console.log(3 > 5);//false

   console.log(3 <= 5);//true

  console.log(3 !== 5);//true

   console.log(3 === '5');//false

逻辑运算符

逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值，后面开发中经常用于多个条件的判断。

• && 逻辑与 简称 与 and ，两侧都是ture结果才是true，只要有一侧是false，结果就是false

• || 逻辑或，简称 或 or ，    两侧都是false结果才是false，只要有一个侧是true，结果就是true.

• ! 逻辑非，简称 非 not 也叫取反，用来取一个布尔值相反的值。如true的相反之是false。

短路运算（逻辑中断）

是值或者是表达式参与逻辑运算的时候，

当多个表达式（值）时，左边的表达式可以确定结果时，就不再运算右边表达式的值；

语法：表达式1&&表达式2

逻辑与短路运算 

如果表达式1结果为真，则返回表达式2.如果表达式1结果为假，'那么返回表达式1.

 如果有空的或者否定的为假 其余是真的。0 ‘’ null undefined NaN 这几个都是假。其余是真。

逻辑或短路运算

如果表达式1结果为真，则返回的是表达式1.如果表示1结果为假，则返回表达式2.

 赋值运算符

用来把数据赋值给变量的运算符。

= 直接赋值

+=、-= 加、减一个数后再赋值

*=、/=、%= 乘除取余 后再赋值

    var a = 10;

    a += 2;//相当于a=a+2

        a -= 2;//相当于 a=a-2

        a *= 3;//相当于 a =a*3

        a /= 3;//相当于a=a/3

运算符优先级

• 一元运算符里面的逻辑非优先级很高
• 逻辑与比逻辑或优先级高

JavaScripe流程控制---分支

在一个程序执行的过程中，各条代码的执行顺序对程序的结果是有直接影响的。很多时候我们要通过控制代码的执行顺序来实现我们要完成的功能。

简单理解：流程控制就是控制代码按照什么结构顺序执行。

流程控制主要有三种结构，分别是顺序结构、分支结构、循环结构。

顺序流程控制

顺序结构没有特定的语法结构，程序会按照代码的先后顺序依次执行。

分支结构控制if语句

由上到下执行代码的过程中，根据不同的条件，执行不同的路径代码（执行代码多选一的过程），从而得到不同 结果。

JS语言提供了两种分支结构语句

• if语句
• switch语句

if语句

if (表达式) {

//执行语句

}

如果if表达式结果为真则执行大括号里面的语句，如果if里面的表达式为假则执行if语句后面的代码。

 

 

if else双分支语句

if (条件表达式）{

//执行语句1

} else {

//执行语句2

}

执行思路：如果条件表达式结果为真，那么执行语句1否则执行语句2.

 

 

if else if 语句（多分枝语句）

就是利用多个条件选择不同的语句执行 得到不同的结果 多选一的过程。

if（条件表达式1）{

//语句1;

} else if (条件表达式2) {

//语句2；

} else if(条件表达式3){

//语句3；

} else {

//最后的语句

}

执行思路：

• 如果条件表达式1满足就执行语句1，执行完毕退出整个if分支语句
• 如果条件表达式1不满足，则判断条件表达式2，满足的话执行语句2 以此类推
• 如果上面的所有条件表达式都不成立，则执行else里面的语句

注意：

• 多分支语句还是多选一 最后只能有一个语句执行
• else if 里面的条件理论上是可以任意多个的

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        var mark = prompt('请输入一个分数');
        if (mark >= 90) {
            alert('A')
        } else if (mark >= 80) {
            alert('b')
        } else if (mark >= 70) {
            alert('C')
        } else if (mark >= 60) {
            alert('D')
        } else {
            alert('E')
        }
        var de = 20;
        var result = de < 10 ? '是的' : '不是';
        console.log(result);

        var time = prompt('请输入一个0-59之间数字');
        var result1 = time < 10 ? '0' + time : time;
        alert(result1);
    </script>
</head>

<body>

</body>

</html>

三元表达式

三元表达式也能做一些简单的条件选择。有三元运算符组成的式子称为三元表达式。

条件表达式 ？ 表达式1 ：表达式2

执行思路

如果条件表达式为真，返回表达式1的值，如果条件表达式结果为假则返回表达式2的值。

        var de = 20;

        var result = de < 10 ? '是的' : '不是';

        console.log(result);

案例

数字补0，用户输入数字，如果数字小于10则在前面补0，比如01 09 如果数字大于10则不需要补比如20.可以用于倒计时使用

    var time = prompt('请输入一个0-59之间数字');

  var result1 = time < 10 ? '0' + time : time;

   alert(result1);

分支流程控制switch语句

switch语句也是多分支语句，它用于基于不同的条件来执行不同的代码。当要针对变量设置一系列的特定值的选项时，就可以使用switch。

语法结构

switch (表达式) {

case value1:

        执行语句1;

        bresk;

case value2:

       执行语句2;

       bresk;

......

default:

      执行最后的语句;

}

执行思路

利用表达式的值和case后面的选项值相匹配，如果匹配上，就执行该case里面的语句，如果都没有匹配上就执行default里面的语句。

switch语句和if else if语句的区别

1.一般情况下他们两个语句可以互相替换

2.switch...case语句通常处理case为比较确定值的情况，if...else...语句更加灵活，常用于范围判断（大于等于某个范围）

3.switch语句进行条件判断后直接执行程序的条件语句，效率更高。而if else语句有几种条件，就得判断多次。

4.当分支较少的时候，if else语句执行效率比switch语句高。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------2022-11-14------------------------------------------------------------------

JS循环结构

循环：可以重复执行某些代码

for循环（重要）

一组被重复执行的语句称之为循环体。能否继续重复执行取决于循环的终止条件。由循环体及循环的终止条件组成的语句，被称之为循环语句

for执行某些代码通常跟计数有关系

for （初始换变量；条件表达式；操作表达式）{

//循环体

}

• 初始变量就是用var声明一个普通变量。通常用于作为计数器使用
• 条件表达式就是用来决定每一次循环是否继续执行 就是终止的条件
• 操作表达式 是每次循环最后执行的代码 经常用于我们计数器变量进行更行（递增或者递减）

执行过程

首先执行计数变量 var i=1,但是 这句话在for循环里只执行一次 index。去i<=100来判断是否满足条件，如满足条件果 就去执行循环体，不满足条件就跳出循环体。这里i满足小于等于100的条件，所以执行循环体打印出“不要懒”，最后执行i++ i++是单独写的代码 ，递增之后i变成了2，到这里第一轮结束。

接着上面的第一轮循环之后i变成了2，再去执行i<=100，满足条件继续往下走执行循环体打印“不要懒”，这是第二次打印了。然后执行i++。这是第二轮循环了，此时的i=3.

重复上面的循环i=3去执行i<=100条件.....

以此类推第100次循环的时候，i=100，满足i<=100的条件。执行循环体打印“不要懒”。再执行i++，i++后i就变成了101了。

上面的i为101了继续执行i<=100，发现此时不满足条件了。就跳出循环体，终止循环。

下面是控制台输出的结果

可以看住打印了100次不要懒，最后的i的值为101.

断点调试

断点调试可以帮助我们观察程序的运行过程

浏览器按f12------->sources------>找到需要调试的文件------->在程序的某一行设置断点

Watch：监视，，通过Watch可以监视变量的值的变化，非常的有用。

双重for循环

单程循环无法满足开发需求，比如我们要打印5行5列的图形，打印一个直角三角形等，此时就可以通过循环嵌套来实现。

循环嵌套是指在一个循环语定义句中再一个循环语句的语法结构，列入再for循环语句中再嵌套一个for循环，这样的for循环语句我们称之为双重for循环。

循环练习

JS循环练习_YuKing_HONG的博客-CSDN博客

for循环小结

• for循环可以重复执行某些相同的代码
• for循环可以重复执行些许不同的代码，因此我们有计数器
• for循环可以重复执行某些操作比如算术运算符加法操作
• 随着需求增加，双重for循环可以做更多更好看的效果。
• for循环条件和字数直接相关的循环
• 双重for循环外层循环一次，内层for循环全部执行
• 分析要比写代码更重要
• 一些核心算法想不到，但是要学会，分析它的执行过程

while循环

while语句可以在条件表达式为真的前提下，循环执行指定的一段代码，直到表达式不为真时结束循环。

当......的时候

while语句的语法结构如下

while（条件表达式）{

//循环体代码

}

执行思路：

1. 先执行条件表达式，如果结果为true则执行循环体代码；如果条件表达式为false则退出循环执行后面代码
2. 执行循环体代码
3. 循环体代码执行完毕后程序会继续执行条件表达式，如果仍然为true则继续执行循环体直到循环条件为false时，整个循环过程才会结束
4. 里面应该也有计数器 初始化变量
5. 里面应该也有操作表达式，完成计数器的更新 防止死循环。

代码练习

do while循环

do ...while循环语句其实是while语句的一个变体。。该循环会先执行一次代码块，然后对条件表达式进行判断，如果条件为真，就会重复执循环体，否则对此循环体。

do {

//循环体

} while (条件表达式)

执行思路

跟while循环体不同的地方在于do while先执行一次循环体 判断条件，如果条件表达式结果为真，则继续执行循环体，否则退出循环体。

注意：先执行循环体再判断，do while 至少执行一次循环体代码。

continue break

continue关键字用于立即跳出本次循环，继续下一次循环体（本次循环体中continue之后的代码就会少执行一次。）

     <script>
   for (var num = 1; num <= 5; num++) {
            if (num == 3) {
                continue;//只要遇到continue就跳出本次循环，直接跳到num++;
            }
            console.log('我在吃第' + num + '个包子');
        }//打印出来结果少了第3个包子


    </script>

         //求1-100之间，除了被7整除之外的整数和

 <script>
//求1-100之间，除了被7整除之外的整数和
        var sum1 = 0;
        for (var n = 1; n <= 100; n++) {
            if (n % 7 == 0) {
                continue;
            }
            sum1 += n;
        }
        console.log(sum1);
     </script>

break关键字

break关键字用于立即跳出整个循环（循环结束）

 //打印出来结果到第二个包子，后面就没有了

记住;break是退出整个循环，碰到了break之后后面的循环不再继续了。所以上面打印出了第二个包子，后面就不再继续了。

JavaScript命名规范已经语法格式

标识符命名规范

• 变量，函数的命名必须要有意义
• 变量的名称一般用名词，sum
• 函数的名称一般用动词，如getsum
• 操作符的左右两侧各保留一个空格
• 单行注释前面注意有个空格

---------------------------2022-11-22---------------------------------------------------------------

数组

1.什么是数据

Array 是一组数据的集合，存储在单个变量下的优雅方式。

2.创建数组

(1) 利用new创建数组

var 数组名=new Array();

     var arr = new Array(); //创建了一个空数组

注意Array（），A要大写

（2）利用数组字面量创建数组 [ ] 常用这种方式

var arr=[ ];

（3）数组里面的数据用逗号,隔开。数组里面的数据成为数组元素，数组元素可以是任何数据类型。

   var arr = [1, 2, 3, 4, 5, 'pink'];

（4）声明数组并赋值称为数组的初始化

3.获取数组元素

3.1数组的索引

索引（下标）：用来访问数组元素的序号（数组序号从0开始）。

获取数组元素，格式 ：数组名[索引号]

  var arr = [1, 2, 3, 4, 5, 'pink'];

  console.log(arr[5]); //控制台得到的是pink

数组可以通过索引来访问，设置，修改对应的数组元素，我们可以通过“数组名[索引]”的形式老获取数组中的元素

这里的访问就是获取得到的意思

4.遍历组数

可以通过“数组名[索引号]”的方式一项项的取出数组每一项。但是比较麻烦。

遍历：就是把数组中的每一个元素从头到尾都访问一次。

数组的长度是元素个数 ，不要和索引号混淆

.length 动态检测数组元素的个数

 课堂练习

<script>
        //求数组所有元素的总和，数组的平均数
        var le = [2, 6, 1, 7, 4];
        var sum = 0;
        var vag = 0;
        for (var i = 0; i < le.length; i++) {
            sum = sum + le[i]

        }
        vag = sum / le.length;
        console.log(sum);
        console.log(vag);
        //求数组最大值
        var arr = [2, 6, 1, 77, 52, 25, 7];
        var max = arr[0];
        for (j = 0; j < arr.length + 1; j++) {
            if (arr[j] > max) {
                max = arr[j];
            }
        }
        console.log(max);
   //数组转换为分割字符串
        //要求：将数组'red', 'green', 'blue', 'pink'输出为：'red|green|blue|pink'
        var color = ['red', 'green', 'blue', 'pink'];
        var str = '';
        for (var n = 0; n < color.length; n++) {
            str += color[n] + '|';
        }
        console.log(str)
    </script>

5.数组中新增元素

可以通过修改length长度以及索引号增加数组元素

• 可以通过修改length长度来实现数组扩容的目的
• length属性是可读写的
• 可以通过修改数组索引的方式追加数组元素
• 不能直接给数组名赋值，否则会覆盖掉以前的数据

<script>
  

        var arr = [2, 6, 1, 77, 52, 25, 7];
        arr.length = 10;//把数组长度扩充到10；
        arr[7] = 66;//新增数组元素，修改索引号追加数组元素
        arr[8] = 56;
        arr[9] = 8;
        console.log(arr);
        arr[0] = 3;//这里原本数组就有arr[0]这元素，现在又重新赋值了一遍，就是替换掉原来的了
        console.log(arr);
        arr = '有点意思';
        console.log(arr);//注意不要直接给数组名赋值否则里面的元素都没有了


        //数组转换为分割字符串
        //要求：将数组'red', 'green', 'blue', 'pink'输出为：'red|green|blue|pink'
        var color = ['red', 'green', 'blue', 'pink'];
        var str = '';
        for (var n = 0; n < color.length; n++) {
            str += color[n] + '|';
        }
        console.log(str);

        //新建一个数组，里面存放10个整数（1-10）
        var str1 = [];
        for (var k = 0; k < 10; k++) {
            str1[k] = parseInt(prompt('请输入一个整数'));
        }
        console.log(str1);
        for (var b = 0; b < 10; b++) {
            str1[b] = b + 1;
        }
        console.log(str1);

    </script>

将数组中大于等于10的数组元素选出来放入新的数组

 删除指定元素

 

冒泡排序

js 数组-冒泡排序，把数组元素按从小到大重新排序。http://t.csdn.cn/S7Ehp

---------------------------------2022-11-24---------------------------------------------------------------

函数

封装了一段可被重复调用执行的代码块。通过此代码块可以实现大量代码的重复使用。

2.1声明函数

function 函数名 （）{

//函数体代码

}

• 调用的时候千万不要忘记添加小括号；
• 口诀：函数不调用，自己不执行。
• 调用方法，函数名（ ）；

注意：声明函数本身不会执行代码，只有调用函数时才会执行函数代码。

3.1函数的参数

可以利用函数的参数实现函数重复不同的代码

   function 函数名(形参1，形参2, ...) {

         //函数体代码

        }

        函数名(实参1，实参2, ...);

形参类似一个变量，形参接受实参。函数的参数可以有也可以没有，，个数不限。

形参：形式上的参数 函数定义的时候传递的参数 当前并灭有知道是什么

实参：实际上的参数 函数调用的时候传递的参数 实参传递给形参的

注意：

• 多个参数用逗号隔开
• 形参可以看作是不用声明的变量

函数形参实参个数匹配

1. 如果参数的个数和形参的个数一直，正常输出结果
2. 如果实参的个数多于形参的个数 会取到形参的个数。
3. 如果实参的个数小于形参的个数，多余的形参定义为undefined 最终结果是NaN

形参可以看作是不用声明的变量，当多余的形参也就是多余的变量没有接收到值，结果就是undefined

4函数的返回值

return语句

有的时候，我们会希望函数将值返回给调用者，此时通过使用return语句就可以实现。

        function 函数名() {

            return 需要返回的结果;

        }

       函数名();

函数只是实现某种功能，最终的结果需要返回给函数的调用者 函数名()；通过return实现

只要函数遇到return就会把后面的结果返回给函数调用者 函数名（）=return后的结果

 <script>   /* 
                function 函数名(){
                    return 需要返回的结果;
                } */
        //利用函数  求两个数的最大值
        function Max(a, b) {
            /*    if (a > b) {
                   return a;
               } else {
                   return b;
               } */

            return a > b ? a : b;
        };
        console.log(Max(611, 9));

        //利用函数求任意一组函数中的最大值
        function getMax(str) {
            var max = str[0];
            for (var i = 0; i < str.length; i++) {
                if (str[i] > max) {
                    max = str[i];
                }
            } return max;
        }
        // console.log(getMax([5, 2, 99, 101, 67, 77]))//实参是一个数组传送过去
        var re = getMax([5, 2, 99, 101, 67, 77]);//实际开发中是这样书写的
        console.log(re);

 </script>

return 终止函数

return语句之后的代码不被执行

return只能返回一个值，如果用逗号隔开多个值，以最后一个为准。如果想要返回多个值，可以考虑用数组形式。

 函数如果有return 则返回的是return 后面的值，如果函数没有return 则返回undefined

通过榨汁机看透函数

pink老师-函数作业

 1、写一个函数，用户输入任意两个数字的任意算术运算（简单的计算器小功能），并能弹出运算结果。

 2.写一个函数，用户输入任意两个数字的最大值，并能弹出运算后的结果

3.写一个函数，用户输入任意三个不同的数字的最大值，并能弹出运算后的结果

4.写一个函数，用户输入一个数，判断是否是素数，并弹出回值（又叫质数，只能被1和自身整除的数）

代码在下面链接

函数作业http://t.csdn.cn/ouzWc

5.arguments的使用

当我们不确定有多少个参数传递的时候，可以用arguments来获取。JavaScript中，arguments实际上它是当前函数的一个内置对象，所有函数内置了一个arguments对象，arguments对象中存储了传递的所有实参。

arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：

• 具有length属性
• 搜索索引方式存储数据
• 不具有数组的push,pop等方法

并不是真正意义上的数组

arguments 是一个对应于传递给函数的参数的类数组对象。只有函数才有arguments对象，而且是内置好了。

 案例：

1.利用函数求任意个数的最大值

<script>
function getMax() {
               var max = arguments[0];
               for (var i = 1; i < arguments.length; i++) {
                   if (arguments[i] > max) {
                       max = arguments[i];
                   }
               }
               return max;
           }
           console.log(getMax(2, 9, 6, 8, 45, 36, 5, 2, 66));
</script>

2.利用函数反转任意数组 reverse 反转

<script>
function reverse(arr) {
            var newArr = [];
            for (var i = arr.length - 1; i >= 0; i--) {
                newArr[newArr.length] = arr[i];
            }
            return newArr;

        }
        console.log(reverse([8, 6, 5, 9, 10]));
        var arr2 = reverse(['red', 'blue', 'pink'])
        console.log(arr2);
</script>