数组

创建数组

利用new创建数组

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

利用 数组字面量 创建数组

        var arr2 = [];//创建了一个空的数组var arr3 = [1,'2','kalise',true];

因为第二种简便，通常用第二种

访问数组元素

        var arr3 = [1,'2','kalise',true];console.log(arr3);console.log(arr3[2]);//kalise

索引号依旧是从0开始的

遍历可以使用for循环，略
数组的长度：数组名.length

        var arr3 = [1,'2','kalise',true];console.log(arr3.length);//4

案例：数组最大值
求数组[2,6,1,77,52,25,7,88,72,43,56]中的最大值：

        var arr = [2,6,77,52,25,7,88,72,43,56];var max=0;for(var i=0;i<arr.length;i++){max>arr[i] ? true:max=arr[i];}console.log(max);

新增数组元素

1.修改length长度：增加 length长度，未赋值的部分为undefined；减少 length会舍弃多出的元素；
2.修改数组索引：

        var arr1 = [1,2];arr1.length=3;console.log(arr1[2]);//undefinedvar arr2 = [3,4];arr2[2]=5;console.log(arr2);//[3,4,5] length:3

对没有定义的数组元素赋值，是增加元素；对已定义的元素赋值就是覆盖

案例：筛选数组

要求：将数组[2,0,6,1,77,10,52,20,25,7]中大于等于10的元素选出来，放入新数组。
方法一：定义一个变量 j

       var arr=[2,0,6,1,77,10,52,20,25,7];var arrNew=[];var j=0;for(var i=0;i<arr.length;i++){/*	if(arr[i]>=10){arrNew[j]=arr[i];j++;} */arr[i]>=10 ? arrNew[j++]=arr[i]:true;}console.log(arrNew);

方法二：使用 arrNew.length

       var arr=[2,0,6,1,77,10,52,20,25,7];var arrNew=[];for(var i=0;i<arr.length;i++){arr[i]>=10 ? arrNew[arrNew.length]=arr[i]:true;}console.log(arrNew);

删除数组指定元素（数组去重）

要求：将数组[2,0,6,1,77,0,52,0,25,7]中的0去掉后，形成一个不包含0的新数组。

       var arr=[2,0,6,1,77,0,52,0,25,7];var arrNew=[];for(var i=0;i<arr.length;i++){arr[i]!=0 ? arrNew[arrNew.length]=arr[i]:true;}arr.length=arrNew.length;for(var i=0;i<arr.length;i++){arr[i]=arrNew[i];}console.log(arr);

翻转数组

       var arr=[2,0,6,1,77,0,52,0,25,7];var arrNew=[];for(var i=0;i<arr.length;i++){arrNew[arr.length-1-i]=arr[i];}/*for(var i=arr.length-1;i>=0;i--){arrNew[arrNew.length]=arr[i];}*/console.log(arrNew);

冒泡排序

假设一个数组有n个数，要求从小到大排：
理解：
从左到右，每两个相邻的数，从前两个数开始依次向右比较，每次的较大者放在右侧，直到最后两个数，从而确定最大的数在最右侧，至此是一轮；在上一轮中确定的数将不再参与比较；以此循环n-1次，确定n-1个数，最后一个数一定是最小的。
确定 i：只需确认n-1个数，i是从0开始的，所以 i<arr.length-1
确定 j：比较前 已经确定的数 的个数为 i，进行比较的是arr[j]和arr[j+1]，j也是从0开始的，所以 j+1<arr.length-i

	    var arr=[4,5,1,3,2];for(var i=0;i<arr.length-1;i++){for(var j=0 ;j<arr.length-i-1;j++){if(arr[j]>arr[j+1]){var temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}console.log(arr);

蓝框表示需要比较的两个数；红色表示比较之后的结果；橘色框表示循环后确定的数，粉色表示数组索引号

我自己也写了一个排序，本以为是冒泡排序，但从算法来看，不大一样，先放这：

       var arr=[4,5,1,3,2];for(var i=0;i<arr.length;i++){for(var j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){var temp=arr[i]arr[i]=arr[j];arr[j]=temp;}}}console.log(arr);

函数

function functionname()
{// 执行代码
}

带参数的函数

function getSum(num1,num2){console.log(num1 + num2);
}
//1.正常输出
getSum(1,2);//3
//实参个数>形参个数，会取到形参的个数，即取1、2，舍弃3
getSum(1,2,3);//3
//实参个数<形参个数，没有接收值的形参，默认为undefined
getSum(1);//NaN

带有返回值的函数

function myFunction()
{var x=5;return x;
}

在您仅仅希望退出函数时 ，也可使用 return 语句。

function myFunction(a,b)
{if (a>b){return;}x=a+b
}

案例：利用函数，求任意数组中的最大值。

        function getMax(arr){var max=arr[0];for(var i=1;i<arr.length;i++){max=max>arr[i] ? max:arr[i];}return max;}var arr1=[54,46,73,28,91];console.log(getMax(arr1));

关于return：
1.return后面的语句不会执行；
2.return只能返回一个结果；returrn num1,num2;这样的只返回num2；
若想返回多个值，可以采用 数组 或者 封装成对象 返回；
3.如果函数没有return，则返回undefined；
关于break，continue，return的区别：
break：结束当前循环体；
continue：跳过本次循环，继续执行下次循环；
return：不仅可以退出循环，还能返回 值，还可以结束当前的函数体内的代码
作业：
写一个函数，用户输入一个数，能判断是否为素数（质数，只能被1和自身整除的数），并返回结果：

       function judgePrinum(num){var temp=0;for(var i=2;i<=num&&temp<=1;i++){num%i==0 ? temp++:1;}return temp==1 ? true:false;}var num=prompt('请输入：');alert(judgePrinum(num));

arguments

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

        function sum(){console.log(arguments); console.log(arguments.length); console.log(arguments[2]); var n=0;for(var i=0; i<arguments.length; i++){n += arguments[i];}return n;}console.log(sum(1,2,3));

arguments的展示形式是一个 伪数组，可以遍历。伪数组 有以下特点：

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

案例：利用函数求任意个数中的最大值：

            function getMax(){var max=arguments[0];for(var i=1;i<arguments.length;i++){if(max<arguments[i]){max=arguments[i];}}return max;}console.log(getMax(32,41,26,55,18));

案例：利用函数封装的方法，翻转任意一个数组：

        function turnArr(arr){var newArr=[];var j=0;for(var i=arr.length-1;i>=0;i--){arr[j++]=arr[i];}return newArr;}var arr1=[1,2,3,4,5,6];console.log(turnArr(arr1));

案例：函数封装冒泡排序：

        function sort(arr){for(var i=0;i<arr.length-1;i++){for(var j=0;j<arr.length-i-1;j++){if(arr[j]>arr[j+1]){var temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}return arr;}var arr=[4,1,5,8,3,2,9,7,6];console.log(sort(arr));

还有很多案例，就不写了

函数的两种声明方式

	//利用函数关键字 自定义函数（命名函数）function fn(){//语句}//函数表达式（匿名函数）var fun=function(str){console.log(str);};fun('可以传参');//（1）fun是变量名 不是函数名//（2）函数表达式声明方式 和 声明变量 差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数//（3）函数表达式也可以传参

作用域

全局作用域和局部作用域（函数作用域），局部变量和全局变量 定义都和C/C++一致。
关于块级作用域：
（1）块级作用域：if {}，for {}等花括号中间的区域；
（2）现阶段js中没有块级作用域 ，就是if {}中定义的变量，if 外面也能使用；
（3）js是在 es6 的时候新增的 块级作用域

注意：未定义的直接赋值使用的变量 视为 全局变量

从执行效率来看全局变量和局部变量：
（1）全局变量只有在浏览器关闭的时候才会销毁，比较占内存
（2）局部变量 当我们的程序执行完毕就会销毁，比较节约内存

作用域链

内部函数访问外部函数的变量，采取的是链式查找的方式 来决定取值，这种结构我们称为 作用域链 。。。。（就近原则）

 var num=10;function fn(){var num=20;function fun(){console.log(num);}fun();}fn();

fun()寻找num时，会先从上一层的外部函数fn()中寻找，找到num=20返回；若fn()中没有num，会再上一层找到全局里的num=10返回。

案例：结果是多少？

        function f1(){var num=123;function f2(){console.log(num);}f2();}var num=456;f1();

闭包

什么是闭包？闭包的优缺点

预解析

引子1：运行

        console.log(num);

因为num没定义，会报错；但如果：

        console.log(num);var num=10;

输出为：undefined。。。为啥子
引子2：

        fn();function fn(){console.log(11);}

可以输出 11；如果是：

        fun();var fun=function(){console.log(22);}

结果会报错！。。。？？？

JS 引擎运行js 分为两步： 预解析 代码执行

什么是预解析？
js引擎 会把js 里面所有的 var 还有 function 提升到当前作用域的最前面

预解析分为 变量预解析（变量提升） 和 函数预解析（函数提升）
（1）变量提升 就是把所有的变量声明 提升到当前的作用域最前面 不提升赋值操作
（2）函数提升 就是把所有的函数声明 提升到当前的作用域最前面 不执行函数

案例：想想输出的结果是什么？

        var num=10;function fn(){console.log(num);var num = 20;console.log(num);}fn();

以上代码，相当于

        var num;function fn(){var num;console.log(num);num = 20;console.log(num);}num=10;fn();

所以输出的结果为 undefined 和 20；
案例：想想输出的结果是？

        f1();console.log(c);console.log(b);console.log(a);function f1(){var a=b=c=9;//相当于var a=9;b=9;c=9;  b和c没有var声明，当全局变量//集体声明   var a=9,b=9,c=9;console.log(a);console.log(b);console.log(c);}

相当于

        function f1(){var a;a=b=c=9;console.log(a);console.log(b);console.log(c);}f1();console.log(c);console.log(b);console.log(a);

输出结果为 5个 9 和 报错；

对象

创建对象

利用对象字面量创建对象：

	var obj={uname:'张三疯',age:18,sex:'男',sayHi:function(){console.log('Hi~');}}console.log(obj.uname);console.log(obj['age']);obj.sayHi();

对象中的函数，称为 方法 ，通过 对象.方法名() 的方式调用。

利用 new Object 创建对象：

	var obj=new Object();//创建了一个空对象obj.uname='张三疯';obj.age=18;obj.sex='男';obj.sayHi=function(){console.log('Hi~');}console.log(obj.uname);console.log(obj['age']);obj.sayHi();

构造函数

因为我们一次创建一个对象，里面有很多的属性和方法是大量相同的。。。我们利用函数的方法，重复这些相同的代码，我们就把这个函数称为 构造函数。这个函数不一样，里面封装的不是普通代码，而是 对象 。
构造函数 就是把我们对象里面一些 相同的属性和方法 抽象出来封装到函数里面。
构造函数 类似于C/C++和Java里面的 类（class）
利用构造函数创建对象：

	function 构造函数名(){this.属性 = 值;this.方法 = function(){}}new 构造函数名();

构造函数的函数名首字母大写；构造函数不需要return，就可以返回结果

	function Star(uname,age,sex){this.name=uname;this.age=age;this.sex=sex;this.sing=function(song){console.log(song);}}var ldh = new Star('刘德华',18,'男');//调用函数返回的是一个对象console.log(ldh['name']);ldh.sing('冰雨');var zxy = new Star('张学友',19,'男');console.log(zxy.name);console.log(zxy.age);zxy.sing('李香兰');

调用构造函数必须使用new，只要new Star()调用函数就创建了一个对象

new在执行时会做的4件事情：

1. 在内存中创建一个新的空对象
2. 让this指向这个新的对象
3. 执行构造函数里面的代码，给这个新对象添加属性和方法
4. 返回这个新对象（所以构造函数里面不需要return）

for…in语句 遍历对象

        var obj = {name : 'kalise',age : 18,sex : '男'}for(var k in obj){console.log(k);//输出 变量k，得到的是 属性名console.log(obj[k]);//输出 obj[k] ，得到的是属性值}

作业：

1. 创建一个电脑对象，该对象要有颜色，重量，品牌，型号，可以看电影，听音乐，打游戏和敲代码。
2. 创建一个按钮对象，该对象中包括包含宽，高，背景颜色和点击行为。
3. 创建一个车的对象，要该对象要有重量，颜色，牌子，可以载人，拉货和耕田。
4. 写一个函数，实现反转任意数组。
5. 写一个函数，实现对数字数组的排序。
   小组项目：
   做一个简易计算器：

内置对象

• JS的对象分为3种：自定义对象、内置对象、浏览器对象
• 内置对象 就是JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
• 内置对象最大的优点就是帮助我们快速开发
• JavaScript提供了多个内置对象：Math、Date、Array、String等

通过查文档学习

学习一个内置对象的使用，只要学会其常用成员的使用即可，我们可以通过查文档学习，可以通过MDN来查询。
MDN：https://developer.mozilla.org/zh-CN/

可以输入函数/方法找用途，也可以输入作用找函数/方法

Math对象

Math内置对象使用手册

    	console.log(Math.PI);console.log(Math.max(1,22,44));console.log(Math.abs(-1));//绝对值console.log(Math.abs('-1'));//隐式转换console.log(Math.floor(1.9));//向下（小）取整console.log(Math.ceil(2.1));//向上（大）取整console.log(Math.round(1.4));//四舍五入console.log(Math.round(1.5));//Math.round()  其他数字都是四舍五入，但  .5  特殊，往大的取console.log(Math.round(-1.1));//-1console.log(Math.round(-1.5));//这个结果是 -1 ，因为-1>-2 

随机数方法：

Math.random()的小细节：
Math.random() 函数返回一个浮点数, 是一个范围在[0,1)之间的伪随机数。这个方法里面不跟参数
如果需要的是整数或有其它需求，可从上面的链接里查找。
比如：我们想要得到两个整数之间的随机整数，并且包含着两个整数：

        function getRandom(min,max){return Math.floor(Math.random()*(max - min + 1)) + min;}console.log(getRandom(1,10));

案例：猜数字游戏
程序随机生成一个1~100之间的数字，并让用户输入一个数字

1. 如果大于该数字，就提示数字大了，继续猜；
2. 如果小于该数字，就提示数字小了，继续猜；
3. 如果等于该数字，就提示猜对了，结束程序。
4. 只有10次的机会

        function getRandom(min,max){return Math.floor(Math.random()*(max - min + 1)) + min;}var result = getRandom(1,100);// console.log(result);var num;var i=10;var numTop=100,end=1;do {num = prompt('请输入数字：（'+end+'~'+numTop+'）');i--;if(num>result){numTop=num;alert('很遗憾╮(╯﹏╰）╭数字大了\n您还有'+i+'次机会');}else if(num==result){alert('恭喜你猜对了！\n‧★,:*:‧\(￣▽￣)/‧:*‧°★*　 \n结果就是'+result);break;}else{end=num;alert('很遗憾╮(╯﹏╰）╭数字小了\n您还有'+i+'次机会');}}while(i>0)if(i==0){alert('很遗憾机会已用完~游戏结束了\n╮(╯﹏╰）╭');}

Date日期对象

Date日期对象使用手册
创建一个新Date对象的唯一方法是通过new 操作符，例如：var now = new Date();同理：

var arr = new Array();//创建了一个数组对象
var obj = new Object();//创建了一个对象实例

若将它作为常规函数调用（即不加 new 操作符），将返回一个字符串，而非 Date 对象。

        console.log(Date());//Thu Jan 20 2022 10:59:50 GMT+0 800 (中国标准时间)

Date的参数：

        //使用Date，如果没有参数，返回当前系统的当前时间var date = new Date();console.log(date);//参数常用的写法  数字型  2022,01,20  或者是  字符串型  '2022-1-20 10:59:50'var date1 = new Date(2022,01,20);console.log(date1);//返回的是 2月 而不是 1月var date2 = new Date('2022-1-20 10:59:50');//最常用console.log(date2);

Date对象和Math对象不一样，Date()是一个构造函数，所以我们需要实例化后才能使用

日期格式

年月日星期

        var date = new Date();console.log(date.getFullYear());//返回当前日期的年  2022console.log(date.getMonth()+1);//月份  返回的月份小1个月  记得月份加1console.log(date.getDate());//返回的是几号console.log(date.getDay());//周一返回的是1，周六返回的是6，周日返回的是0//我们写一个 2022年1月20日 星期四var year = date.getFullYear();var month = date.getMonth()+1;var dates = date.getDate();var arr = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'];var day = date.getDay();console.log('今天是：'+year+'年'+month+'月'+dates+'日 '+arr[day]);

时分秒

        var date = new Date();console.log(date.getHours());//时console.log(date.getMinutes());//分console.log(date.getSeconds());//秒//要求封装一个函数返回当前的时分秒 格式 08:08:08function getTime(){var time = new Date();var h = time.getHours();h = h<10 ? '0'+h : h;var m = time.getMinutes();m = m<10 ? '0'+m : m;var s = time.getSeconds();s = s<10 ? '0'+s : s;return h + ':' + m + ':' + s;}console.log(getTime());

两个合并一下：

        var date = new Date();var year = date.getFullYear();var month = date.getMonth()+1;var dates = date.getDate();var arr = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'];var day = date.getDay();//要求封装一个函数返回当前的时分秒 格式 08:08:08function getTime(time){var h = time.getHours();h = h<10 ? '0'+h : h;var m = time.getMinutes();m = m<10 ? '0'+m : m;var s = time.getSeconds();s = s<10 ? '0'+s : s;return h + ':' + m + ':' + s;}console.log('现在北京时间 '+year+'年'+month+'月'+dates+'日 '+getTime(date)+' '+arr[day]);

获取日期的总的毫秒形式（时间戳）
Date对象是基于1970年1月1日（世界标准时间）起的毫秒数
我们通常利用总的毫秒数来计算时间，因为它更精确
获得Date总的毫秒数是指距离1970年1月1日过了多少毫秒数
四种方法：

        var date = new Date();//1.通过 valueOf() getTime()console.log(date.valueOf());//就是我们现在时间 距离1970.1.1 总的毫秒数console.log(date.getTime());//2.简单的写法（最常用的写法）var date1 = +new Date();//返回的就是总的毫秒数console.log(date1);//3.H5新增的console.log(Date.now());

案例：倒计时效果
案例分析：

1. 核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时，但是不能拿着十分秒直接相减，比如05分减去25分，结果会是负数
2. 用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数
3. 把剩余时间总的毫秒数转换成天、时、分、秒（时间戳转换为十分秒）
   转换公式如下
   d = parseInt(总秒数/60/60/24); //计算天数
h = parseInt(总秒数/60/60 %24);//计算小时
m = parseInt(总秒数/60 %60); //计算分钟数
s = parseInt(总秒数%60); //计算当前秒数

课上老师的代码是：

        function countDown(time){//'2022-1-21 14:00:00'var nowTime = +new Date();var endTime = +new Date(time);var times=Math.floor((endTime-nowTime)/1000);//倒计时总秒数if(times<=0){return;}var d =Math.floor(times/3600/24);d=d>10 ? d:'0'+d;var h =Math.floor(times/3600%24);h=h>10 ? h:'0'+h;var m =Math.floor(times/60%60);m=m>10 ? m:'0'+m;var s =Math.floor(times%60);s=s>10 ? s:'0'+s;return d+'天 '+h+':'+m+':'+s;}console.log(countDown('2022-1-21 14:00:00'));

这样只能显示一次剩余时间，不能自动计时倒数；留下一篇文章，日后细究：【JavaScript】分秒倒计时器

数组对象

new Array()，其实就是第二种创建数组的方式：

var arr1 = new Array();//创建一个空的数组
var arr2 = new Array(2);//创建了一个长度为2的数组，数组元素为空
var arr3 = new Array(2,3);//等价于arr3=[2,3]

检测是否为数组

函数传参，当形参为数组而实参不为数组时，会出现bug，所以需要检测传递过来的参数是否为数组。
注意大小写：

		var arr = [];var obj = {};//第一种方式：instanceof 运算符 console.log(arr instanceof Array);//返回trueconsole.log(obj instanceof Array);//返回false//第二种方式：Array.isArray(参数); H5新增的方法console.log(Array.isArray(arr));//trueconsole.log(Array.isArray(obj));//false

增删数组元素

方法名	说明	返回值
push(参数1…)	在数组末尾添加一个或多个元素	返回新的长度
pop()	删除数组最后一个元素，把数组长度减1	返回它删除的最后一个元素的值
unshift(参数1…)	在数组的开头添加一个或更多元素	返回新的长度
shift()	删除数组的第一个元素，数组长度减1	返回删除的第一个元素的值

        //push()var arr = [1,2,3];console.log(arr.push(4,'kalise'));//5console.log(arr);//unshift()console.log(arr.unshift('good'));console.log(arr);//pop()console.log(arr.pop());console.log(arr);//shift()console.log(arr.shift());console.log(arr);

案例：筛选数组
有一个包含工资的数组[1500,1200,2000,2100,1800]，要求把数组中工资超过2000的删除，剩余的放到新数组中：

        var arr = [1500,1200,2000,2100,1800];var arrNew = [];for(var i=0;i<arr.length;i++){if(arr[i]<2000){//arrNew[arrNew.length]=arr[i];arrNew.push(arr[i]);}}

数组排序：

方法名	说明	是否修改原数组
reverse()	颠倒数组中元素的顺序	会改变原来的数组，返回新数组
sort()	对数组的元素进行排序	会改变原来的数组，返回新数组

注意arr.sort(function(a,b){return b-a;});的写法。更多

        //翻转数组var arr = ['red','blue','yellow'];arr.reverse();console.log(arr);//数组排序（冒泡排序）var arr1 = [12,4,7,34,26,10,8];arr1.sort(function(a,b){//return a-b;//升序的顺序排序return b-a;//降序的顺序排序});console.log(arr1);

获取数组元素索引

方法名	说明	返回值
indexOf()	在数组中查找给定元素的第一个索引	如果存在，返回索引号；如果不存在，返回-1
lastIndexOf()	在数组中查找给定元素的最后一个索引	如果存在，返回索引号；如果不存在，返回-1

        var arr = ['red','green','blue','pink','blue','black'];//有两个blueconsole.log(arr.lastIndexOf('blue'));console.log(arr.indexOf('blue'));console.log(arr.indexOf('yellow'));

数组去重

有一个数组[‘c’,‘a’,‘z’,‘a’,‘x’,‘a’,‘x’,‘c’,‘b’]，要求去除重复元素。

        var arr = ['c','a','z','a','x','a','x','c','b'];function unique(arr){var arrNew = [];for(var i=0;i<arr.length;i++){//if(arrNew.indexOf(arr[i])===-1)if(i==arr.indexOf(arr[i])){arrNew.push(arr[i]);}}return arrNew;}console.log(unique(arr));

数组转换为字符串

方法名	说明	返回值
toString()	数组转换成字符串，每一项之间用逗号分隔	一个字符串
join(‘分隔符’)	数组转换成字符串，每一项之间用输入的 分隔符 分隔	一个字符串

        //toString()var arr = [1,2,3];console.log(arr.toString());//1,2,3//join(分隔符)var arr1 = ['green','blue','pink'];console.log(arr1.join());//green,blue,pinkconsole.log(arrr1.join('-'));//green-blue-pink

课后查询：

方法名	说明	返回值
concat()	连接两个或多个数组 不影响原数组	返回一个新的数组
slice()	数组截取slice(begin,end)	返回被截取项目的新数组
splice()	数组删除splice(第几个开始，要删除的个数)，注意，这个会影响原数组	返回被删除的项目的新数组

slice()和splice()的目的基本相同，建议重点看splice()。链接指南：concat()；slice()；splice()

字符串对象

	var str = 'andy';console.log(str.length);//4

思考：对象 才有 属性和方法，复杂数据类型 才有 属性和方法，简单数据类型为什么会有length属性呢？

基本包装类型

就是把 简单数据类型 包装成为了 复杂数据类型。这样基本数据类型就有了属性和方法。
当你写出str.length时，相当于执行了：

	//（1）生成临时变量，把简单数据类型包装为复杂数据类型var temp = new String('andy');//（2）把临时变量的值 给 strstr = temp;//（3）销毁临时变量temp = null;

JS提供了三个特殊的引用类型：String、Number和Boolean。

字符串的不可变性

当我们var str = 'andy'时，就在内存中开辟了一个空间，在里面存放'andy'，然后声明一个变量 str，用这个 str 指向存放'andy'的空间；当我们str = 'city'时，又会在内存中在开辟一个空间存放'city'，让 str 重新指向'city'的空间，'andy'的空间并没有销毁、改变。
因为字符串的不可变性，所以不要大量的拼接字符串。

根据字符返回位置

字符串的所有方法，都不会修改字符串本身（字符串是不可变的），操作完成后会返回一个新的字符串。

方法名	说明
indexOf(‘要查找的字符’，开始的位置)	返回指定内容在原字符串中的位置，如果找不到就返回-1，开始的位置是index索引号
lastIndexOf()	从后往前找，只找第一个匹配的

        var str = '改革春风吹满地，春天来了';console.log(str.indexOf('春'));//2console.log(str.indexOf('春',3));//8console.log(str.lastIndexOf('春'));//8

案例：返回字符串位置
查找字符串’abcoefoxyozzopp’中所有o出现的位置以及次数
老师的范例：

        var str = "abcoefoxyozzopp" ;var index = str.indexOf('o');var num = 0;while ( index !==-1) {console.log(index);num++ ;index = str.indexOf('o', index + 1);}console.log( 'o出现的次数是:'+ num);

我的：

        var str = 'abcoefoxyozzopp';function seekO(){var temp = -1;var arr = [];do{temp=str.indexOf('o',temp+1);if(temp!=-1){arr.push(temp);}}while(temp!=-1)return arr;}var arr=seekO();console.log('共出现了'+arr.length+'次，分别在'+arr.join('、')+'处。');

根据位置返回字符

方法名	说明	使用
charAt(index)	返回指定位置的字符（index符号串的索引号）	str.charAt(0)
charCodeAt(index)	获取指定位置处的ASCII码（index索引号）	str.charCodeAt(0)
str[index]	获取指定位置处字符	HTML5，IE8+支持 和charAt()等效

        // 1. charAt(index) 根据位置返回字符var str = 'andy';console.log(str.charAt(3));//遍历所有的字符for(var i=0;i<str.length;i++){console.log(str.charAt(i));}// 2. charCodeAt(index) 返回相应索引号的字符ASCII值 目的: 判断用户按下了那个键console.log(str.charCodeAt(0)); // 97// 3. str[index] H5新增的console.log(str[0]); // a

案例：统计字符串中出现最多的字符和次数

做案例之前先理解一下，以下代码：

        var o = {age:18}if(o['age']){console.log('有age');//输出}else{console.log('没有age');}if(o['sex']){console.log('有sex');}else{console.log('没有sex');//输出}

o[‘age’] 返回的是18；o[‘sex’] 返回的是undefined
理解之后做以下案例：
判断一个字符串’abcoefoxyozzopp’中出现次数最多的字符，并统计其次数。（重点案例）
核心算法：

• 利用charAt() 遍历这个字符串
• 把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就+1
• 遍历对象，得到最大值和该字符

        var str = 'abcoefoxyozzopp';var o = {};for(var i = 0;i<str.length;i++){//str.charAt(i)为每一个字符：'a','b','c'...if(o[str.charAt(i)]){o[str.charAt(i)]++;}else{o[str.charAt(i)]=1;}} //遍历var max = 0;var ch = '';for(var k in o){//k 得到的是 属性名；o[k]得到的是 属性值if(o[k]>max){max = o[k];ch = k;}}console.log('出现最多的字符是'+ch+'，共出现了'+max+'次'); /*var maxchar=str.charAt(0);for(var k in o){// console.log(k+':'+o[k]);maxchar=o[maxchar]>o[k] ? maxchar:k;} console.log('出现最多的字符是'+maxchar+'，共出现了'+o[maxchar]+'次'); */

字符串操作方法

方法名	作用	说明
concat(str1,str2,str3…)	连接	用于连接两个或者多个字符串。拼接字符串，等效于+。
substr(start,length)	截取	从start位置开始（索引号），length是取的字符个数（重点记住这个）
slice(start,end)	截取	从start位置开始，截取到end位置，end取不到（他们俩都是索引号）
substring(start,end)	截取	从start位置开始，截取到end位置，end取不到 基本和slice相同 但是不接受负值
replace(‘a’,‘b’)	替换	a为 被替换的字符，b为 替换为的字符。只能替换第一个字符，全部替换需要使用循环
split(‘分隔符’)	转换	将字符串转换为数组，str=‘red,pink,blue’; str.split(’,’);//[‘red’,‘pink’,‘blue’]

课下查询：toUpperCase() //转换大写； toLowerCase() //转换小写
作业：
给定一个字符串，如： "abaasdffggghjkkglddssss3444343” ，问题如下：
1、字符串的长度
2、取出指定位置的字符，如：0,3,5,9等
3、查找指定字符是否在以 上字符串中存在，如：i , c , b等
4、替换指定的字符，如：g替换为22，ss替换为b等操作方法
5、截取指定开始位置到结束位置的字符串，如：取得1-5的字符串
6、找出以上字符串中出现次数最多的字符和出现的次数

简单数据类型与复杂数据类型

简单数据类型=基本数据类型=值类型：string,number,boolean,undefined,null
复杂数据类型=引用类型：对象、数组
简单数据类型中 null 返回的是一个空的对象 object

堆和栈

堆栈空间分配区别:
1、栈(操作系统) ：由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈；
简单数据类型存放到栈里面
2、堆(操作系统) ：存储复杂类型(对象) ，一 般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。
复杂数据类型存放到堆里面
简单数据类型：声明age，在栈中开辟空间存放18，age指向它；
复杂数据类型：声明arr，在堆中开辟空间存放数组的值[1,2,3]，在栈中开辟空间存放 数组的地址，arr指向地址，地址指向数组的值；
var age = 18;和var arr = [1,2,3];

注意: JavaScript中没有堆栈的概念，通过堆栈的方式，可以让大家更容易理解代码的一些执行方式，便于将来学习其他语言

简单数据类型传参

说简单点就是，形参是函数新开辟的空间，对外面的实参没有影响。跟那个局部变量差不多的概念。

复杂数据类型传参

-------------------------------------------------------------------------- 分割线---------------------------------------------------------------------------
完
这两篇是我跟着B站的视频自学做的笔记，原视频BV号为BV1ux411d75J