JS基础语法

Js基本语法

Js的使用方式：

1. 行内js

写在标签中的js代码

1. 内部js

写在页面中的js代码

1. 外部js

引入外部的js代码

注意：1.若是<script></script>标签设置了src属性，则在双标签中写的js代码无效

           二、一般使用JS时，会选择内部JS或外部JS

语句：

           JS代码是以行为单位，一行一行执行。

           通常状况下，一行一条语句。

              每句语句后面最好加上分号，若是一行写多条语句（不建议），则每条语句后面必须加分号。

           若是是表达式，不须要加分号，若是加了JavaScript引擎会把它当作语句编译。

注释：

           单行注释：   // 注释内容

           多行注释：   /* 注释内容 */

           Html风格：<!-- html的注释-- >

变量的声明

              JavaScript 是一种弱类型语言，在声明变量时不须要指明数据类型，直接用 var 修饰符进行声明。

两种方式：

                   一、先声明，后赋值

                   二、声明并赋值

                                              

变量的注意点

                   1）若只声明而没有赋值，则该变量的值为 undefined。

                   2）变量要有定义才能使用，若变量未声明就使用，JavaScript 会报错，告诉你变量未定义

                   3）能够在同一条 var 命令中声明多个变量。

                   4）若使用 var 从新声明一个已经存在的变量，是无效的。

                   5）若使用 var 从新声明一个已经存在的变量且赋值，则会覆盖掉前面的值

                   6）JavaScript 是一种动态类型、弱类型语言，也就是说，变量的类型没有限制，能够赋予各类类型的值。

                   7）声明变量时，能够不加var修饰符，此时变量为全局变量（不建议）

                                    

变量提高

                   JavaScript 引擎的工做方式是，先解析代码，获取全部被声明的变量，而后再一行一行地运行。

JS是弱类型语言，变量没有类型，但数据有类型。

                                     JavaScript 中有 6 种数据类型。

                                     其中有五种简单的数据类型：

Undefined、Null、布尔、数值和字符串。

                                     一种复杂数据类型 Object。

                                              

                                     数 值（Number）： 整数和小数（好比 1 和 3.14）

                                     字符串（String）： 字符组成的文本（好比"Hello World"）

                                     布尔值（Boolean）：true（真）和 false（假）两个特定值

                                     Undefined： 表示“未定义”或不存在，即此处目前没有任何值

                                     Null： 表示空缺，即此处应该有一个值，但目前为空

对象（object）(引用) ： 各类值组成的集合

                                     1)、对象（object）{name:"zhangsan",age:"18"}

                                     2)、数组（array）[1,2,3]

                                    3)、函数（function）function test() {}

                                    

一、typeof 操做符

                                     typeof 操做符是用来检测数据类型。

说明：一、typeof null 返回的是 object 字符串

二、函数不是数据类型，可是也可使用 typeof 操做符返回字符串。

typeof 操做符能够操做变量也能够操做字面量。

注意：函数在 JavaScript 中是对象，不是数据类型，因此使用 typeof 区分 function 和object 是有必要的

                   这形成的结果，就是全部的变量的声明语句，都会被提高到代码的头部，这就叫作变量提高。

注意：变量提高只对 var 命令声明的变量有效，若是一个变量不是用 var 命令声明的，就会发生变量提高。

 

 

undefined

                   undefined 类型的值是 undefined。

                   undefined 是一个表示"无"的原始值，表示值不存在。

                   常见的undefined的状况：

                                     一、当一个变量只声明而未赋值时

                                     二、当一个函数须要形参，调用时未传递形参，此时参数为undefined

                                     三、当一个函数没有返回值，调用方式时去接收，会返回undefined

                                                       

null

null 类型是只有一个值的数据类型，即特殊的值 null。它表示空值，即该处的值如今为空，

                   它表示一个空对象引用。

                   使用 Null 类型值时注意如下几点：

                                     1）使用 typeof 操做符测试 null 返回 object 字符串。

                                     2）undefined 派生自 null，因此等值比较返回值是 true。因此，未初始化的变量和赋值为null 的变量相等。

                                    

数值型

                   数值型包含两种数值：整型和浮点型。

                   1）全部数字（整型和浮点型）都是以 64 位浮点数形式储存。因此，JS 中 1 与 1.0 相等，并且 1 加上 1.0 获得的仍是一个整数。浮点数最高精度是 17 位小数，因为浮点数运算时可能不精确，尽可能不要使用浮点数作判断。

                   2）在存储数值型数据时自动将能够转换为整型的浮点数值转为整型。

                   3）对于过大或太小的数值，可使用科学计数法来表示

4）Infinity、-Infinity

                   超过了表数范围，出现 Infinity（正无穷）或者-Infinity（负无穷）

                   isFinite()函数能够肯定是否超出范围：

                   true：没有超出；false：超出了。

NaN

                   表示非数值（Not a Number），是一个特殊的值。

                   如：将字符串解析成数字出错的场合。

                   注意：

                            NaN 不等于任何值，包括它自己,由于它不是一个值

                            NaN 与任何数（包括它本身）的运算，获得的都是 NaN。

                                                                          

                   isNaN()能够用来判断一个值是否为 NaN

                            true：不是数字；false：是数字

                                    

字符串

                   使用 ' ' 或 " "引发来，如：'sxt'，"good"。

                   使用加号’+’进行字符串的拼接，如：console.log('hello' + ' everybody');

                                    

                                    

对象

                   对象是一组数据和功能的集合。

                   typeof window // "object"

                   typeof {} // "object"

                   typeof [] // "object"

                   typeof null // "object"

                   说明：

                            {}：表示使用对象字面量方式定义的对象。空的大括号表示定义包含默认属性和方法的对象。

instanceof 运算符

                   typeof 操做符对数组（array）和对象（object）的显示结果都是 object，那么能够利用

                   instanceof 运算符，它可用于判断一个变量是否某个对象的实例。

 

 

 

parseInt()和 parseFloat()两个全局转换函数。

                   前者把值转换成整数，后者把值转换成浮点数。

                   只有对 String 类型调用这些方法，这两个函数才能正确运行；

                   对其余类型返回的都是 NaN(Not a Number)。

                                    

parseInt()

                   会从下标0开始找，若是不是有效数字，返回NaN；若是是，则继续日后找，直到不是有效数字位置

                 parseInt()方法还有基模式，能够把二进制、八进制、十六进制或其余任何进制的字符串转换成整数。基是由 parseInt()方法的第二个参数指定的

                   若是十进制数包含前导 0，那么最好采用基数 10，这样才不会意外地获得八进制的值

parseFloat()方法

                   与 parseInt()方法的处理方式类似，从位置 0 开始查看每一个字符，直到找到第一个非有效的字符为止，而后把该字 符以前的字符串转换成数字。

                   不过，对于这个方法来讲，第一个出现的小数点是有效字符。

                   若是有两个小数点，第二个小数点将被看做无效的，parseFloat()方法会把这个小数点以前的字符串转换成数字。

 

 

显式转换

                   toString()函数将内容转换为字符串形式

                   toFixed()函数将根据小数点后指定位数将数字转为字符串，四舍五入

                   注：不能对null和undefined使用

                                              

强制转换

                   JS 为 Number、Boolean、String 对象提供了构造方法，用于强制转换其余类型的数据。

                   此时操做的是整个数据，而不是部分

                                              

                   String()是最简单的，由于它可把任何值转换成字符串。

                   String()和toString()的区别，在于前者能够操做null和undefinded

 

 

数组的建立

                   var arr=[值 1,值 2,值 3]; //隐式建立

                   var arr=new Array(值 1,值 2,值 3); //直接实例化

                   var array=new Array(size); //建立数组并指定长度

                                              

基本操做

                   一、数组的长度能够经过 length 属性来获取，并能够任意更改

                   二、数组中的每个元素均可以被访问和修改，甚至是不存在的元素，无所谓越界

                                              

数组的遍历

                   一、for(var i=0; i < 数组.length; i++) {}

                   二、for(var 下标名  in 数组) {}

                   三、数组.forEach(function(元素，下标){});

                                              

了解：

                   若是下标：

                   1.为非负整数(包括整数字符串)：自动从 0 开始,不存在添加 undefined

                   2.为负数、小数、非数字符串：这些内容不计算在长度内，当成"属性"处理，至关于自定义属性。

                   数组很是灵活，使用数组元素

                   1.下标: 非负整数(包括整数字符串)：

                   数组.下标

                   数组[下标]

                   2.下标：负数、小数、非数字字符串：

                   数组[属性]

                                                                        

                   * for -- > 不遍历属性

                   * foreach -- >不遍历属性和索引中的 undefined

                   * for in -- >不遍历索引中的 undefined

                                                                

                                    

数组中提供的经常使用方法

                   push 添加元素到最后

                   unshift 添加元素到最前

                   pop 删除最后一项

                   shift 删除第一项

                   reverse 数组翻转

                   join 数组转成字符串

                   indexOf 数组元素索引

                   slice 截取（切片）数组，原数组不发生变化

                   splice 剪接数组，原数组变化，能够实现先后删除效果

                   concat 数组合并

 

1. 函数的定义

                   有三种函数定义的方式：函数声明语句、函数定义表达式、Function 构造函数

函数声明语句

                   function 函数名([参数列表]) {}

                   调用：函数名([参数列表]);

函数定义表达式

                   var 变量名/函数名 = function([参数列表]) {}

                   调用：变量名/函数名([参数列表]);

Function 构造函数

                   var 变量名 = new Function("参数1","参数2","最后一个参数为是函数体");

                   调用：变量名/函数名([参数列表]);

注意：

                   一、js 中的函数没有重载，同名的函数，会被后面的函数覆盖。

                   二、js 中容许有不定数目的参数

 

 

 

函数的参数

                    实参能够省略，那么对应形参为 undefined

                   若函数形参同名（通常不会这么干）：在使用时以最后一个值为准。

                   能够给参数默认值：当参数为特殊值时，能够赋予默认值。

                   参数为值传递，传递副本 ；引用传递时传递地址，操做的是同一个对象。

                                    

函数的调用

                   经常使用调用方式：函数名([实参]);

                   存在返回值能够变量接收，若接收无返回值函数则为 undefined

                   一、函数调用模式

                   二、方法调用模式

                   三、间接调用模式

                   call()和 apply()方法能够用来间接地调用函数。

                   任何函数能够做为任何对象的方法来调用，哪怕这个函数不是那个对象的方法。

                   两个方法均可以指定调用的实参。

                   call()方法使用它自有的实参列表做为函数的实参，apply()方法则要求以数组的形式传入参数

                                    

                   匿名函数当即调用

                   （1）匿名函数：function ([参数]){}

                   （2）调用：(function ([形参]) {})([实参]);

                   在函数只被使用一次的状况下可使用这种方式，简便省事

                                                       

return 语句

                   做用：在没有返回值的方法中，用来结束方法。

                   有返回值的方法中，一个是用来结束方法，一个是将值带给调用者。