有的同学可能会好奇，为什么js的版本要用es+年份（例如es2015，es2016等），而不是js+年份，这就要说到ECMAScript(简称es)，ECMAScript是一个语言标准，javascript则是基于这个标准实现的脚本语言。
javascript于1996年发布了第一版，当时的名字其实不叫javascipt，而是叫livescript，不过发布之后一直不温不火，正好这个时候sun公司推出来了一个面向对象的语言—Java，Java拥有很好的跨平台特性，一处编写处处执行，很快得到了市场的认可。
熟悉 Java、C 和 Perl 这些语言的开发者会发现 ECMAScript 的语法很容易掌握，因为它借用了这些语言的语法。
好了，废话不多说，直接开篇点题，下面是我在学习ECMAScript的过程中总结一些知识要点以及用自己的话理解ECMAScript
-
首先，我们学习这们语言首先要明白什么是JavaScript
* 是一门脚本语言 * 是一门解释性语言 * 是一门动态类型的语言 * 是一门基于对象的语言 -
然后简单的理解一下页面中有什么代码
* html--展示内容,css---美化页面的,js---控制页面 -
那么JavaScript的作用是什么呢？
* 解决用户和浏览器之间的交互的问题
在js文件中可以写js代码,但是需要在html的页面中引入 script的标签中的src="js的路径"
下面是在引用script标签中一些常见的问题：
- 在一对script的标签中有错误的js代码,那么该错误的代码后面的js代码不会执行
- 如果第一对的script标签中有错误,不会影响后面的script标签中的js代码执行
- script的标签中可以写什么内容 type="text/javascript"是标准写法或者写language="JavaScript"都可以
但是,目前在我们的html页面中,type和language都可以省略,原因:html是遵循h5的标准
- 有可能会出现这种情况:script标签中可能同时出现type和language的写法.
- script标签在页面中可以出现多对
- script标签一般是放在body的标签的最后的,有的时候会在head标签中,目前讲课的时候都在body标签的后面(body中的最后)
- 如果script标签是引入外部js文件的作用,那么这对标签中不要写任何的js代码,如果要写,重新写一对script标签,里面写代码
正确的代码规范
扫描二维码关注公众号，回复： 7658674 查看本文章
- js中声明变量都用var
- js中的每一行代码结束都应该有分号;(写代码有分号的习惯)
- js中的大小写是区分的: var N=10; n
- js中的字符串可以使用单引号,也可以使用双引号
变量：
- 变量作用:用来操作数据的(可以存储,可以读取)
- 变量的声明:没有赋值
- var 变量名;
- 变量的初始化:有赋值
- var 变量名=值;
变量名的注意问题—变量名的命名规范,要遵循驼峰命名法
- 变量的名字要有意义,
- 变量名有一定的规范:一般以字母,$符号,下划线开头,中间或者后面可以有$符号,字母,数字
- 变量名一般都是小写的
- 变量名如果是多个单词,第一个单词的首字母是小写的,后面的所有的单词的首字母都是大写的,这种命名方式称为:驼峰命名法
- 不能使用关键字(系统自带的一些单词,不能使用)
- 不会单词用拼音,拼音也要遵循驼峰命名法
在写代码的时候是需要养成良好的注释习惯，注释:是解释代码的含义,给其他的程序员看的
JavaScript中注释的方式:
1.单行注释 // 单行注释:一般用在一行代码的上面
2.多行注释 /**/
现在开始进入正题
数据类型：
* number:数字类型(整数和小数)
* string:字符串类型(的值一般都是用单引号或者是双引号括起来) "34"
* boolean:布尔类型(值只有两个,true(真1),false(假0))
* null:空类型,值只有一个:null,一个对象指向为空了,此时可以赋值为null
* undefined:未定义,值只有一个:undefined
* 什么情况下的结果是undefined
* 变量声明了,没有赋值,结果是undefined
* 函数没有明确返回值,如果接收了,结果也是undefined
* 如果一个变量的结果是undefined和一个数字进行计算,结果:NaN不是一个数字,也没有意义
* object:对象---->
数字类型：
- 数字类型:整数和小数
- num=20;整数
- num=98.76;小数(其他的语言中,浮点型—单精度,双精度浮点)
- 所有的数字都是属于number类型 其他的语言:
- 整数类型:int
- 单精度浮点型:float
- 双精度浮点型:double
扩展：
无论是整数还是小数都是数字类型
不要用小数验证小数
不要使用NaN判断是不是NaN，应该使用isNaN(值或者是变量)
想要表示十进制:就是正常的数字
想要表示八进制:以0开头
想要表示十六进制:0x开头
字符串类型：
字符串可以使用单引号,也可以使用双引号 字符串的拼接: 使用+可以把多个字符串放在一起形成一个字符串
只要有一个是字符串,其他的是数字,那么结果也是拼接,不是相加 如果有一个是字符串,另一个不是字符串,使用-
号,此时会发生计算(浏览器帮助我们自动的把字符串类型转成了数字类型,这种方式叫:隐式转换)类型转换：
.parseInt();//转整数 .parseFloat()//转小数 .Number();//转数字
.toString()//转字符串
//如果变量有意义调用.toString()使用转换
//如果变量没有意义使用String()转换
操作符：一些符号-----用来计算
算数运算符:
* 算数运算表达式:由算数运算符连接起来的表达式 + - * / %
* 一元运算符: 这个操作符只需要一个操作数就可以运算的符号 ++ --
* ++ 和 -- 可以分为:前+ 和后+ and 前- 和后-
* 如果++在后面:如: num++ +10参与运算
* 先参与运算,运算结束后自身再加1
* 如果++在前面:如: ++num+10参与运算
* 先自身加1,然后再参与运算
* 二元运算符: 这个操作符需要两个操作数就可以运算,
* 三元运算符: 运算符号: ? :
* 复合运算符: += -= *= /= %=
* 复合运算表达式:由复合运算符连接起来的表达式
* 关系运算符: > < >= <= ==不严格的 ===严格的 !=不严格的不等 !==严格的不等
* 关系运算表达式:由关系运算符连接起来的表达式
* 关系运算表达式的结果是布尔类型
逻辑运算符:
* &&---逻辑与--并且
* ||---逻辑或---或者
* !---逻辑非---取反--取非
* 逻辑运算表达式:由逻辑运算符连接起来的表达式
* 表达式1&&表达式2
* 如果有一个为false,整个的结果就是false
* 表达式1||表达式2
* 如果有一个为true,整个的结果为true
* !表达式1
* 表达式1的结果是true,整个结果为false
* 表达式1的结果是false,整个结果为true
*
* 赋值运算符: =
流程控制:有三种方式
* 1.顺序结构:从上到下,从左到右执行的顺序,就叫做顺序结构(不是很眼睛)
* 2.分支结构:if语句,if-else语句,if-else if-else if...语句,switch-case语句,三元表达式语句
* 3.循环结构:while循环,do-while循环,for循环,后期还有一个for-in循环
- if语句:主要是判断
语法:
if(表达式){
代码块
}
执行过程:
先判断表达式的结果是true还是false,如果是true则执行代码块,如果是false,大括号中的代码是不执行的
- if-else语句的语法:
if(表达式){
代码1
}else{
代码2
}
执行过程:
如果表达式的结果是true则执行代码1,如果表达式的结果是false,则执行代码2
- if-else if语句…
语法:
if(表达式1){
代码1
}else if(表达式2){
代码2
}else if(表达式3){
代码3
}else{
代码4
}
- else if—这种结构可以写多个,具体多少个看需求
- else–结构是可以不用写的,具体也是看需求
执行过程:
先判断表达式1的结果,
如果为true则执行代码1
如果为false,则判断表达式2
如果表达式2为true则执行代码2
如果为false,则判断表达式3
如果表达式3为true则执行代码3
否则执行代码4
- switch-case语句—分支语句—多分支语句
语法:
switch(表达式){
case 值1:代码1;break;
case 值2:代码2;break;
case 值3:代码3;break;
case 值4:代码4;break;
...多个case
default:代码5;
break;
}
注意问题:
default后面的break是可以省略的
default也可以省略
switch-case 语句中和case后面的值比较的时候使用的是严格的模式
break是可以省略
执行过程:
获取表达式的值,和值1比较,如果一样,则执行代码1,遇到break则跳出整个的语句,后面代码不执行
如果表达式的值和值1不一样,则和值2比较,如果相同则执行代码2,遇到break则跳出
否则和值3比较,相同则执行代码3,遇到break,跳出,否则和值4比较,相同则执行代码4,遇到break则跳出,否则直接执行代码5
总结------分支语句:
- if语句:一个分支
- if-else语句:两个分支,最终只执行一个分支
- if-else if-else if…语句: 多个分支,也是只会执行一个
- switch-case语句:多分支语句,最终也会一个(必须要有break)
- 三元表达式:和if-else语句是一样的
- 什么时候使用if-else if…: 一般是对范围的判断
- 什么时候使用switch-case语句:一般是对具体的值的判断
- 如果有多个分支,是针对范围的判断一般选择if-else if的语句
- 如果有多个分支,是针对具体的值判断,一般选择用switch-case语句
while循环语法:
计数器
var 变量=0;
while(循环的条件){
循环体;
计数器++;
}
执行过程:
先判断条件是否成立,(条件的结果是true还是false),如果是false,那么循环的代码(while的大括号中的代码都不执行),如果是true,那么先执行循环体,然后执行计数器,然后,直接去—>循环的条件,再次判断是否成立,成立则继续执行循环体,否则跳出循环,执行完循环体之后,计数器加1,然后再去循环的条件,判断,成立则循环,否则跳出循环
- do-while循环
语法:
do{
循环体
}while(条件);
执行过程:
先执行一次循环体,然后判断条件是否成立,不成立,则跳出循环,成立则执行循环体,然后再判断条件是否成立,成立则继续循环,否则跳出…
- for循环
语法:
for(表达式1;表达式2;表达式3){
循环体;
}
执行过程:
先执行一次表达式1,然后判断表达式2;如果不成立则直接跳出循环
如果表达式2成立,执行循环体的代码,结束后,跳到表达式3执行,然后跳到表达式2,判断表达式2是否成立,不成立,则跳出循环
如果表达式2成立,则执行循环体,然后再跳到表达式3,再跳到表达式2,判断是否成立,一直如此
注意：
break关键字:如果在循环中使用,遇到了break,则立刻跳出当前所在的循环
continue:在循环中如果遇到continue关键字,直接开始下一次循环
数组:
- 通过构造函数创建数组
语法:
var 数组名=new Array();
var array=new Array();//定义了一个数组
数组的名字如果直接输出,那么直接就可以把数组中的数据显示出来,如果没有数据,就看不到数据
var 数组名=new Array(长度);
如果数组中没有数据,但是有长度—,数组中的每个值就是undefined
构造函数的方式创建数组的时候,如果在Array(一个数字)—>数组的长度(数组元素的个数)
如果在Array(多个值);这个数组中就有数据了,数组的长度就是这些数据的个数
- 通过字面量的方式创建数组
var 数组名=[];//空数组
var array=[];
无论是构造函数的方式还是字面量的方式,定义的数组,如果有长度,那么默认是undefined
* 数组:一组有序的数据
* 数组的作用:可以一次性存储多个数据
* 数组元素:数组中存储的每个数据,都可以叫数组的元素,比如:存储了3个数据,数组中3个元素
* 数组长度:就是数组的元素的个数,比如有3个元素,就说,这个数组的长度是3
* 数组索引(下标):用来存储或者访问数组中的数据的,索引从0开始,到长度减1结束
* 数组的索引和数组的长度的关系:长度减1就是最大的索引值
*
* 如何设置数组中某个位置的值
* 数组名[下标]=值;
* arr[3]=100;
* 如何获取数组中某个位置的值
* var result=数组名[下标];
* console.log(result);
总结：
- var 数组名=new Array();空数组
- var 数组名=new Array(值);数组定义了,有长度
- var 数组名=new Array(值1,值2,值3…);定义数组并且有多个数据
- var 数组名=[];空数组
- var 数组名=[值1,值2,值3];有三个数据
- 数组元素:就是数组中存储的数据
- 数组长度:就是数组中元素的个数
- 数组索引(下标):从0开始,到数组的长度减1结束
- 通过下标设置数组的元素值: 数组名[索引]=值
- 通过下标访问数组的元素值: 数组名[索引]
函数:
把一坨重复的代码封装,在需要的时候直接调用即可
函数的作用:代码的重用
函数的定义
语法:
function 函数名字(){
函数体-----一坨重复的代码
}
函数的调用:
函数名();
函数参数:
- 在函数定义的时候,函数名字后面的小括号里的变量就是参数,目的是函数在调用的时候,用户传进来的值操作
- 此时函数定义的时候后面的小括号里的变量叫参数;写了两个变量,就有两个参数,
- 在函数调用的时候,按照提示的方式,给变量赋值—>就叫传值,把这个值就传到了变量(参数)中
- 形参:函数在定义的时候小括号里的变量叫形参
- 实参:函数在调用的时候小括号里传入的值叫实参,实参可以是变量也可以是值
函数的返回值:
在函数内部有return关键字,并且在关键字后面有内容,这个内容被返回了
当函数调用之后,需要这个返回值,那么就定义变量接收,即可
- 如果一个函数中有return ,那么这个函数就有返回值
- 如果一个函数中没有return,那么这个函数就没有返回值
- 如果一个函数中没有明确的返回值,那么调用的时候接收了,结果就是undefined
- (没有明确返回值:函数中没有return,函数中有return,但是return后面没有任何内容)
- 函数没有返回值,但是在调用的时候接收了,那么结果就是undefined
- 变量声明了,没有赋值,结果也是undefined
- 如果一个函数有参数,有参数的函数
- 如果一个函数没有参数,没有参数的函数
- 形参的个数和实参的个数可以不一致
- return 下面的代码是不会执行的
定义一个函数,如果不确定用户是否传入了参数,或者说不知道用户传了几个参数,没办法计算,获取的是函数在调用的时候,传入了几个参数
- arguments----->可以获取函数调用的时候,传入的实参的个数
- arguments是一个对象,是一个伪数组
- arguments.length—>是实参的个数
- arguments[索引]---->实参的值
console.log(arguments.length);
使用arguments对象可以获取传入的每个参数的值
console.log(arguments);
- 命名函数:函数如果有名字,就是命名函数
- 匿名函数:函数如果没有名字,就是匿名函数
- 函数的另一种定义方式
- 函数表达式:
- 把一个函数给一个变量,此时形成了函数表达式
var 变量=匿名函数; //函数表达式
例子:
var f1=function (){
};
如果是函数表达式,那么此时前面的变量中存储的就是一个函数,而这个变量就相当于是一个函数,就可以直接加小括号调用了
f1();
注意:
函数表达式后面,赋值结束后,要加分号
函数可以作为参数使用,如果一个函数作为参数,那么我们说这个参数(函数)可以叫回调函数
只要是看到一个函数作为参数使用了,那就是回调函数
function one(fn) {
console.log("one函数");
fn();//fn此时应该是一个函数
}
function two() {
console.log("two函数");
}
one(two);
函数是可以作为返回值使用的:
function f1() {
console.log("f1函数调用了");
return function () {
console.log("这是一个函数");
};
}
var ff=f1();//调用
ff(); //ff就是一个函数了
作用域:使用范围
- 全局变量:声明的变量是使用var声明的,那么这个变量就是全局变量,全局变量可以在页面的任何位置使用
- 除了函数以外,其他的任何位置定义的变量都是全局变量
- 局部变量:在函数内部定义的变量,是局部变量,外面不能使用
- 全局变量,如果页面不关闭,那么就不会释放,就会占空间,消耗内存
- 全局作用域:全局变量的使用范围
- 局部作用域:局部变量的使用范围
- 块级作用域:一对大括号就可以看成是一块,在这块区域中定义的变量,只能在这个区域中使用,但是在js中在这个块级作用域中定义的变量,外面也能使用;
- 说明:js没有块级作用域,只有函数除外
- 隐式全局变量:声明的变量没有var,就叫隐式全局变量
- 全局变量是不能被删除的,隐式全局变量是可以被删除的
- 定义变量使用var是不会被删除的,没有var是可以删除的
- 预解析:就是在解析代码之前
- 预解析做什么事?
- 把变量的声明提前了----提前到当前所在的作用域的最上面
- 函数的声明也会被提前—提前到当前所在的作用域的最上面
函数调用的时候,把会函数的声明提升到作用域的上面
f1();//调用
var num=20;//这个变量的声明会提升到变量使用之前
function f1() {
console.log(num);
var num=10;
}
扩展：
预解析中,变量的提升,只会在当前的作用域中提升,提前到当前的作用域的最上面
函数中的变量只会提前到函数的作用域中的最前面,不会出去
预解析会分段(多对的script标签中函数重名,预解析的时候不会冲突)
面向过程:凡事都要亲力亲为,每件事的具体过程都要知道,注重的是过程
面向对象:根据需求找对象,所有的事都用对象来做,注重的是结果
面向对象特性:封装,继承,多态 (抽象性)
js不是面向对象的语言,但是可以模拟面向对象的思想
js是一门基于对象的语言
什么是对象?
- 看的见,摸得到,具体特指的某个东西
分析对象有什么特点:特征和行为
对象:有特征和行为,具体特指的某一个事物
对象:有属性和方法,具体特指的某个事物
创建对象三种方式:
- 调用系统的构造函数创建对象
var 变量名= new Object(); Object 是系统的构造函数 Array
var obj = new Object();
//对象有特征---属性和行为---方法
//添加属性-----如何添加属性? 对象.名字=值;
obj.name = "张三";
obj.age = 23;
obj.sex = "男";
console.log(obj.name);//获取--输出了
console.log(obj.age);
console.log(obj.sex);
//方法的调用
obj.eat();
obj.play();
obj.cook();
//添加方法----如何添加方法? 对象.名字=函数;
obj.eat = function () {
console.log("我喜欢吃油炸榴莲凉拌臭豆腐和大蒜");
};
2.自定义构造函数创建对象(结合第一种和需求通过工厂模式创建对象)
//自定义构造函数创建对象,我要自己定义一个构造函数,自定义构造函数,创建对象
//函数和构造函数的区别；名字是不是大写(首字母是大写)
function Person(name,age) {
this.name=name;
this.age=age;
this.sayHi=function () {
console.log("我叫:"+this.name+",年龄是:"+this.age);
};
}
//自定义构造函数创建对象:先自定义一个构造函数,创建对象
var obj=new Person("张三",23);
console.log(obj.name);
console.log(obj.age);
obj.sayHi();
获取属性另一种方法：
obj["name"]="李四";
console.log(obj["name"]);
obj["sayHi"]();
3.字面量的方式创建对象
//字面量创建对象的缺陷: 一次性的对象
var obj={
name:"小明",
age:38,
sex:"女"
};
obj.name="小三";
console.log(obj.name);
点语法: 对象.名字=值; 对象.名字=函数;
扩展
如何获取该变量(对象)是不是属于什么类型的?
变量 instanceof 类型的名字----->布尔类型,true就是这种类型,false不是这种类型
在当前的对象的方法中,可以使用this关键字代表当前的对象
工厂模式
- 如何一次性创建多个对象?把创建对象的代码封装在一个函数中
//工厂模式创建对象
function createObject(name,age) {
var obj = new Object();//创建对象
//添加属性
obj.name = name;
obj.age = age;
//添加方法
obj.sayHi = function () {
console.log("我叫:" + this.name + "我今年:" + this.age);
};
return obj;
}
//创建人的对象
var per1 = createObject("张三",23);
per1.sayHi();
//创建一个人的对象
var per2 = createObject("李四",24);
per2.sayHi();
小结：
- 代码(变量)只有执行到这个位置的时候,才知道这个变量中到底存储的是什么,如果是对象,就有对象的属性和方法,如果是变量就是变量的作用
- 对象没有什么,只要点了,通过点语法,那么就可以为对象添加属性或者方法
JSON格式的数据:一般都是成对的,是键值对,
json也是一个对象,数据都是成对的,一般json格式的数据无论是键还是值都是用双引号括起来的
var json = {
"name": "小明",
"age": "10",
"sex": "男"
};
//遍历对象,是不能通过for循环遍历,无序
//key是一个变量,这个变量中存储的是该对象的所有的属性的名字
var key="name";
console.log(json[key]);
//可以通过for-in循环
for(var key in json){
console.log(key);//json对象中的属性的名字
console.log(json[key]);
}
//对象中确实有这个属性对象.属性名字 或者对象[属性名字]
简单类型和复杂类型
原始数据类型: number,string,boolean,undefined, null,object
基本类型(简单类型),值类型: number,string,boolean
复杂类型(引用类型):object
空类型:undefined,null
值类型的值在哪一块空间中存储? 栈中存储
引用类型的值在哪一块空间中存储?对象在堆上存储,地址在栈上存储
var num=10;//值类型,值在栈上
var obj={};//复杂类型,对象在堆,地址(引用)在栈
值类型之间传递,传递的是值
引用类型之间传递,传递的是地址(引用)
值类型作为函数的参数,传递的是值
引用类型作为函数的参数,传递的是地址
js学习中三种对象:
* 内置对象----js系统自带的对象
* 自定义对象—自己定义的构造函数创建的对象
* 浏览器对象—浏览器的
* 内置对象:
* Math
* Date
* String
* Array
* Object
实例对象:通过构造函数创建出来,实例化的对象 静态对象:不需要创建,直接就是一个对象,方法(静态方法)直接通过这个对象名字调用,
new 的执行过程:----->new的时候，系统做了什么事?
* 1. 开辟空间,存储创建的新的对象
* 2. 把this设置为当前的对象
* 3. 设置属性和方法的值
* 4. 返回当前的新的对象
实例方法必须通过实例对象调用
静态方法必须通过大写的对象调用
实例方法---->必须要通过new的方式创建的对象(实例对象)来调用的方法
静态方法---->直接通过大写的构造函数的名字调用的方法(直接通过大写的对象名字调用的)
- Math 是一个对象,但是不是一个函数
- Math对象下的属性和方法都是静态
Math.PI----π---
Math.E----常数的底数
Math.abs(值)-----绝对值
Math.ceil(值)----向上取整
* Math.Max()---一组数字中的最大值
* Math.Min()---一组数字中的最小值
* Math.abs()----绝对值
* Math.random---随机数字
* Math.sqrt()----开平方
* Math.pow()----一个数字的多少次幂
Date：
var dt=new Date(); //当前的时间---当前的服务器
var dt=+new Date();//一种特殊的写法,只适用于这个Date的对象
console.log(dt);
dt.getFullYear();//年
dt.getMonth();//月---从0开始
dt.getDate();//日
dt.getHours();//小时
dt.getMinutes();//分钟
dt.getSeconds();//秒
dt.getDay();//星期---从0开始
dt.toDateString();//日期
dt.toLocaleDateString();//日期
dt.toTimeString();//时间
dt.toLocaleTimeString();//时间
dt.valueOf();//毫秒
- String---->是一个对象
- 字符串可以看成是字符组成的数组,但是js中没有字符类型
- 字符是一个一个的,在别的语言中字符用一对单引号括起来
- 在js中字符串可以使用单引号也可以使用双引号
- 因为字符串可以看成是数组,所以,可以通过for循环进行遍历
- 字符串特性:不可变性,字符串的值是不能改变
- 字符串的值之所以看起来是改变的,那是因为指向改变了,并不是真的值改变了 // string ---->字符串类型----基本类型
String---->字符串类型----引用类型
- .length------>字符串的长度
- .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串
- .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值
- .concat(字符串1,字符串2,…);返回的是拼接之后的新的字符串
- .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1
- .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1
- .replace(“原来的字符串”,“新的字符串”);用来替换字符串的
- .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串
- .split(“要干掉的字符串”,切割后留下的个数);切割字符串
- .substr(开始的位置,个数);返回的是截取后的新的字符串
- .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串
- .toLocaleLowerCase();转小写
- .toLowerCase();转小写
- .toLocaleUpperCase()转大写
- .toUpperCase();转大写
- .trim();干掉字符串两端的空格 字符串的常用属性:
- .length------>字符串的长度
- .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串
- .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值
- .concat(字符串1,字符串2,…);返回的是拼接之后的新的字符串
- .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1
- .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1
- .replace(“原来的字符串”,“新的字符串”);用来替换字符串的
- .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串
- .split(“要干掉的字符串”,切割后留下的个数);切割字符串
- .substr(开始的位置,个数);返回的是截取后的新的字符串
- .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串
- .toLocaleLowerCase();转小写
- .toLowerCase();转小写
- .toLocaleUpperCase()转大写
- .toUpperCase();转大写
- .trim();干掉字符串两端的空格
Array.isArray(对象)---->判断这个对象是不是数组
instanceof关键字
.concat(数组,数组,数组,…) 组合一个新的数组
.every(函数)–返回值是布尔类型,函数作为参数使用,函数中有三个参数,第一个参数是元素的值，第二个参数是索引值,第三个参数是原来的数组(没用)
如果这个数组中的每个元素的值都符合条件,最后才返回的是true
.filter(函数);返回的是数组中每一个元素都复合条件的元素,组成了一个新的数组
.push(值);—>把值追加到数组中,加到最后了—返回值也是追加数据之后的数组长度
.pop();—>删除数组中最后一个元素,返回值就是删除的这个值
.shift();—>删除数组中第一个元素,返回值就是删除的这个值
.unshift();—>向数组的第一个元素前面插入一个新的元素,----返回值是插入后的程度
.forEach(函数)方法—遍历数组用—相当于for循环
.indexOf(元素值);返回的是索引,没有则是-1
.join(“字符串”);----返回的是一个字符串
.map(函数);—>数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中
.reverse();----->反转数组
.sort();—排序的,可能不稳定,如果不稳定,请写MDN中的那个固定的代码
.arr.slice(开始的索引,结束的索引);把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值
.splice(开始的位置,要删除的个数,替换的元素的值);一般是用于删除数组中的元素,或者是替换元素,或者是插入元素
基本包装类型
普通变量不能直接调用属性或者方法
对象可以直接调用属性和方法基本包装类型:本身是基本类型,但是在执行代码的过程中,如果这种类型的变量调用了属性或者是方法,那么这种类型就不再是基本类型了,而是基本包装类型,这个变量也不是普通的变量了,而是基本包装类型对象
好的，基本语法就讲解到这里希望可以帮助大家如有有错的请大家指正，我会及时修改。