Java教程

Javascript基础

本文主要是介绍Javascript基础,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

JavaScript基础

1.JavaScript

1.1.JavaScript介绍

JavaScript是轻量级的编程语言,是一种运行在客户端浏览器中,由浏览器解析的脚本语言。 脚本语言:即不需要编译,直接可以被浏览器解析和执行。

1.2.JavaScript组成

一个完整的JavaScript实现是由以下3个不同部分组成的:核心(ECMAScript)、文档对象模型(Document Object Model,简称DOM)、浏览器对象模型(Browser Object Model,简称BOM) window是JS中的内置对象,代表整个浏览器窗口,是BOM中的一员 documenet是JS中的内置对象,每个载入浏览器的HTML文档都会成为document对象,是DOM中的一员 JavaScript是一种弱类型的编程语言,是基于事件驱动的编程语言。每一个JS事件都会对应一个事件句柄,事件句柄的名称是:on+事件名。例如:click是鼠标单击事件,onclick是鼠标单击事件句柄,当click事件触发时,onclick单击事件句柄注册的“JS代码”就会执行.

1.3.基本用法

JS需要和HTML一起使用才有效果,我们可以通过直接或者间接的方式将JS代码嵌在HTML页面中。

行内JS:写在标签内部的JS代码

内部JS:定义在<script>标签内部的JS代码

外部JS:单独的JS文件,在HTML中通过<script>标签引入

我们可以将Javascript的代码放在HTML文件中的任意位置,但是我们一般放在网页的head或者body部分,由于页面加载的方式是从上往下依次加载的,而这个对我们放置的js代码运行是有影响的。

【js放置的位置】

             1. 放在head标签中
             2. 放在body中
             3. 放在body标签后(推荐)

放在<head>部分:最常用的的方式是在页面中head的部分放置<script>元素,浏览器解析head的部分就会执行这个代码,然后才会解析页面的其余部分。

放在<body>部分:Javascript代码在网页读取到该语句的时候才会执行。

js代码从上往下依次执行,最好等到html元素执行完毕后在执行js代码。

【行内JS代码】:将JS代码写在html标签内部

 <button type="button" onclick="alert('hello world !')">按钮</button>

【内部JS代码】:将JS代码<script>标签中

         <script type="text/javascript">
             alert('hello world !')
         </script>

【外部JS】:在js文件夹中创建js文件,通过<script>标签引入JS文件

 <script src="js/test.js" type="text/javascript" charset="utf-8"></script>

【注意事项】:

1.onlick 点击事件,当点击元素时触发

2.alert("内容")弹出层

3.console.log(""); 打印内容在控制台,与Java的sout很相似。

4.页面按F12弹出控制台

注:如果你在<script>标签里写了 src属性,那么你在这个<script>里再写代码是无效的,这就是它跟内部JS代码的一个区别。

     <script src="" type="text/javascript" charset="utf-8">
 ​
     alert("哈哈哈哈") <!-- 有src=""这句代码是不会执行的 -->
 ​
     </script>

2.Javascript基础语法

2.1.语句和注释

Javascript程序执行单位为行,也就是一行一行的执行。一般情况下,每一行就是一个语句。

语句是为了完成某种任务而进行的操作,语句以分号结尾,一个分号即表示语句结束。多个语句可以写在一行内(不建议这样子做),但当一行写多条语句时,语句必须以分号结尾。

表达式不需要分号结尾,一旦在表达式后面添加分号,则Javascript引擎就将表达式视为语句,这样会产生一些没有任何意义的语句。

单行注释:// 注释的内容 //

多行注释:/* 注释的内容 */

兼容html注释方式:< !-- -- >

2.2.标识符和关键字

标识符就是一个名字,用来给变量和函数进行命名,有特定的规则和规范

【规则】:

由Unicode字母、_、$、数字组成、中文组成

(1) 不能以数字开头

(2)不能是关键字和保留字

(3)严格区分大小写

【规范】:

(1)见名知意

(2)驼峰命名法: 第一个单词首字母小写,后面其他单词首字母大写。

ex: int myAge; char myName[10]; float manHeight;

关键字也称保留字,是被Javascript征用的特殊含义的单词。

break、case、catch、continue、default、delete、do、else、finally、for、function、if、in、instanceof、new、return、switch、this、throw、try、typeof、var、void、while、abstract、boolean、byte、char、class、const、debugger、double、enum、export、extends、final、float、goto、implements、import、int、interface、long、native、package、private、protected、public、short、static、super、synchronized、throws、transient、volatile。

2.3.变量(**)

变量即一个带名字的用来存储数据的空间,数据可以存储到变量中,也可以从数据中取出变量。

2.3.1.变量的声明

Js是一种弱类型语言,在声明变量时不需要指明类型1,直接用var修饰符来进行声明。

【变量声明和赋值】:

 // 先声明在赋值
 var a;
 a = 10;
 // 声明时赋值
 var b = 10;

2.3.2.变量的注意点

  • 若只声明没有赋值,则变量的值为undefined。

 var x;
 console.log(x);
  • 变量需要定义才能使用,若变量未声明就使用,JS会报错,告诉你未定义变量。因为一切事物不会凭空产生!

 console.log(x2);   // 报错!
  • 可以在同一条var命令中声明多个变量。

 var a, b, c = 100;
  • 若使用var重新声明一个已经存在了的变量,是无效的。

 var x3 = 10;
 var x3; // 无效
  • 若使用var重新声明一个已经存在了的变量,并且给它赋值,则会覆盖掉之前的值。

 var x4 = 10;
 var x4 = 20; // 此时 x4的值变为了20
  • JS是一种动态型、弱类型语言,也就是说,变量的类型没有限制,可以赋予各种类型的值。

 var x5 = 10;
 x5 = 1.23;
 x5 = "hello world !";
 x5 = 'a';
 x5= true;

2.3.3.变量提升(了解)

Javascript引擎工作方式是,先解析代码,获取所有被声明的变量,然后再一行一行的运行,这样造成的结果就是,所有的变量声明语句都会被提升到代码的头部,这就叫做变量提升。

 console.log(str);
 var str = "12345";
  
  // 变量提升相当于:
  var str;
  console.log(str);
  str = "12345";
  
  // 注:最后输出结果为undefinded,表示str已经声明,但还未赋值

注:变量提升只对var命令声明的变量有效,如果变量不是用var明了声明的,就不会有变量提升。

2.4.数据类型

虽说JS是弱类型语言,变量没有类型,但是数据本身是有类型的。针对不同的类型,我们可以使用不同的操作。

Javascript中有6种数据类型,其中有五种简单的数据类型:Undefined、Null、布尔、数值和字符串,一种复杂数据类型Object.

【五种简单的数据类型】

  1. Undefined:表示未定义或者不存在,即此处目前没有任何值

  2. Null:表示空缺,即此处应该有一个值,但目前为空

  3. 布尔值(Boolean):true表示真;false表示假

  4. 数值(Number):整数和小数 比如 2 和 3.1415

  5. 字符串(String):字符组成的文本 如 "hello !"

【一种复杂数据类型】:对象(Object)(引用):各种值组成的集合

1)、对象(object) {name: "张三" , age: "18"}

2)、数组(array) [1,2,3,4]

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

2.4.1.undefined

undefined类型的值是undefined。

undefined是一个表示“无”的原始值,表示不存在。

【出现undefined的常见情况】:

(1)当声明一个变量而没有初始化赋值时,这个变量的值就是undefined

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

(2)调用函数时,该函数有形参,但未提供实参,则该参数为undefined

             var str;
             function test(str){
                 console.log(str);
             }
             test(); //调用函数时,该函数有形参,但未提供实参,则该参数为undefined

(3)函数没有返回值时,默认返回undefined

             var str;
             function test(str){
                 console.log(str);
             }
             var a = test(1);
             console.log(a); // 函数没有返回值时,默认返回undefined

2.4.2null

null类型是只有一个值的数据类型,即特殊的值null,它表示空值,即该处的值现在为空,它表示一个空对象引用。

使用null的注意事项:

  1. 使用typeof操作符测试null返回object字符串。

  2. undefined派生自null,所以等值比较返回的是true,未初始化的变量和赋值为null的变量相等。

         <script type="text/javascript">
 ​
             var a = 1;
             var b = true;
             console.log(typeof(a)); // number
             console.log(typeof(b)); // boolean
             
             //使用typeof操作符测试null返回字符串Object
             var c = null;
             console.log(typeof(c));// object
             
             //2undefined派生自null,所以等值比较返回的是true,未初始化的变量和赋值为null的变量相等
             var d;
             console.log(d); // undefined
             console.log(c==d); // true
 ​
         </script>

 

2.4.3.布尔

布尔类型有两个值:true,false,常用来判断循环的条件。

2.4.4.数值型

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

  • 所有的数字,都是以64位浮点数存储,所以,JS中1与1.0相等,且1加上1.0得到的还是一个整数(整数+xxx.0得的还是整数),浮点数的最高精度是17位小数,由于浮点数运算时间可能不精确,尽量不用浮点数做判断。

     var a = 1;
     var b = 1.0;
     console.log(a==b);//true
     
     console.log(1+1.0);//2
  • 在存储数值型数据时自动将可以转化为整形的浮点数(1.0)转化成整型(1)

     var c = 1.0;
     console.log(c);// 1

2.4.5.字符串

使用 ' ' , 或""引起来,如:'hello',"good"。

使用+号可以实现字符串拼接。

2.4.6.对象

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

2.5.类型转换

2.5.1.自动类型转换

在执行数学运算的时候会触发自动转换,转换规则如下:

  • undefined转换为NaN

  • null和""转换为数组时为0,转布尔类型为false

  • 非空字符串数值型转换为布尔类型为true

  • 非空字符串转换为数值类型,转换成功;不是数字型失败

  • 0转布尔为false,非0转布尔为true

2.5.2.函数转换(String to Number)

Js提供了parseInt()和parseFlaot()两个全局转换函数。前者把值转换成整数,后者把值转换成浮点数。只有对String类型调用这些方法,这两个函数才能正确运行;对其他类型返回的都是NaN(Not a Number)。

2.5.2.1.parseInt()

在转换之前,首先会分析该字符串,判断位置为0处的字符,判断它是否是个有效数字,如果不是,则直接返回NaN,不再继续。如果是则继续,直到找到非有效字符。

     <script type="text/javascript">
         //在转换之前,首先会分析该字符串,判断位置为0处的字符,判断它是否是个有效数字,不是则直接返回NaN
         console.log(parseInt("a123bc")); //NaN      
         console.log(parseInt("1.234")); //1
         //位置为0处的字符是有效数字是继续,直到找到非字符。
         console.log(parseInt("12abc.34")); //12
         
     </script>
2.5.2.2parseFloat()

该方法与parseInt()方法的处理方式相似,从位置为0处的字符查看每一个字符,判断它是否是个有效数字,直到找到非有效字符为止,然后把该字符之前的字符串转成数字。不过对于这个方法来说,第一个出现的小数点是有效字符。如果有两个小数点,则第二个看作为无效,parseFloat()方法会把这个小数点之前的字符串转成数字。

         console.log(parseFloat("1234abc")); //1234
         console.log(parseFloat("1.234")); //1.234
         console.log(parseFloat("12.34.56")); //12.34
         console.log(parseFloat("a123bc")); //NaN

2.5.3.显示转换

几乎每个对象都提供了toString()函数将内容转换为字符串形式。其中Number提供的toString()函数可以将数字转为字符串。

Number还提供了toFixed()函数将根据小数点后指定的位数将数字转为字符串,结果四舍五入。

         var data = 123;
         console.log(data);
         console.log(data.toString()); // 将数字转为字符串
         
         var data2 = null;
         // console.log(data2.toString()); 报错:Cannot read property 'toString' of null
         
         var data3 = 1.234;
         var data4 = 1.256;
         console.log(data3.toFixed(1)); // 1.2
         console.log(data4.toFixed(1)); // 1.3

JS为Number、Boolean、String对象提供了构造方法,用于强制转换其他类型的数据。此时操作都是整个数据,而不是部分

     // 转换的是一个整体 
     console.log(Number("5.5")); // 5.5
     console.log(Number("56")); // 56
     console.log(Number("5.6.7")); //NaN
     
     //String() 任何类型都可以转成字符串
     var data1 = null;
     var data2 = undefined;
     console.log(String(data1)); // "null"
     console.log(String(data2)); // "undefined"
 // 注:toString()方法是不能将null和undefined转成字符串的

最简单的转字符串方式:任意数据后面+""

     //最简单的转字符串方式:任意数据后面+""
     var data3 = 123+"";
     console.log(data3);// "123"(黑色)

2.6运算符

运算符用于执行程序代码运算,会针对一个及以上操作来进行运算。

2.6.1算术运算符

y=5,下面的表格解释了这些算术运算符:

运算符描述例子x 运算结果y 运算结果
+ 加法 x=y+2 7 5
- 减法 x=y-2 3 5
* 乘法 x=y*2 10 5
/ 除法 x=y/2 2.5 5
% 取模(余数) x=y%2 1 5
++ 自增 x=++y 6 6
x=y++ 5 x=y++ 5 6
-- 自减 x=--y 4 4
x=y-- 5 x=y-- 5 4

2.6.2赋值和扩展运算符

【赋值运算符】

赋值运算符用于给 JavaScript 变量赋值。

给定 x=10y=5,下面的表格解释了赋值运算符:

运算符例子等同于运算结果
= x=y   x=5
+= x+=y x=x+y x=15
-= x-=y x=x-y x=5
*= x*=y x=x*y x=50
/= x/=y x=x/y x=2
%= x%=y x=x%y x=0

【比较运算符】

比较运算符在逻辑语句中使用,以测定变量或值是否相等。

x=5,下面的表格解释了比较运算符:

运算符描述比较返回值
== 等于 x==8 false
x==5 *true x==5 true
=== 绝对等于(值和类型均相等) x==="5" false
x===5 *true x===5 true
!= 不等于 x!=8 true
!== 不绝对等于(值和类型有一个不相等,或两个都不相等) x!=="5" true
x!==5 *false x!==5 false
> 大于 x>8 false
< 小于 x<8 true
>= 大于或等于 x>=8 false
<= 小于或等于 x<=8 true
     <!-- == 与 === 区别 -->
     // = 相等:比较值是否相等
     //=== 完全相等:比较值和类型都一样
 ​
     var a = 1;
     var b = "1";
     console.log(a==b); // true
     console.log(a===b); // false

【逻辑运算符】

逻辑运算符用于测定变量或值之间的逻辑。

给定 x=6 以及 y=3,下表解释了逻辑运算符:

运算符描述例子
&& and (x < 10 && y > 1) 为 true
|| or (x==5 || y==5) 为 false
! not !(x==y) 为 true

2.7.控制语句

同之前Java基础。

2.8.数组(**)

数组是按次序排列的一组数据,每个值的位置都有编号(从0开始),整个数组用方括号显示。

2.8.1.数组的定义

JS中数组的定义有三种方式(也可以先声明再赋值):

 var arr = [值1,值2,值3...]; //隐式创建
 ​
 var arr = new array(值1,值2,值3...); // 直接实例化
 ​
 var arr = new array(size); // 创建数组并指定长度

2.8.2.基本操作

数组的长度可以通过length属性来获取,并可以任意更改。

 数组名.length
 数组名.length = 长度

数组中每一个元素都可以被访问(通过索引获取)和修改,甚至是不存在的元素,无所谓越界

 获取元素:数组名[下标]
 修改元素:数组名[下标] = 新值

数组的特点:

  • 长度可变

  • 数组中数据类型任意

  • 索引从0开始

  • 可以使用任意字符做数组的索引,如果索引是非正整数,我们称之为数组的属性,属性不影响数组的长度。

2.8.3.数组遍历

JS中数组的遍历方式有以下三种:

【1】普通for循环

 for (var i = 0; i < array.length; i++) {
     console.log(array[i])
 }

【2】for....in

 for(var 下标(名称任意) in 数组名){
         数组名[下标];//获取元素  
 }
 如:
 var array = [1,2,3.4,"a","abc"];
     for(var index in array){
         console.log(index)
         console.log(array[i])
         console.log("------------")
     }
 ​
 

【3】forEach

 数组名.foeEach(function(element,index){
         // element(名称任意):元素
         // index(名称任意):下标
 })
 如:
     var array = [1,2,3.4,"a","abc"];
     //设置属性:
     array['yourName'] = "zhangsan";
     
     
     array.forEach(function(element,index){
         console.log(element);
         console.log(index);
         console.log("--------");
     
     })
 ​

普通for——不遍历属性

forEach——不遍历属性和索引中的undefined

for...in——不便利索引中的undefined

2.8.4.数组提供的操作方法

 push            添加元素到最后
 unshift         添加元素到最前
 pop             删除最后一项
 shift           删除第一项
 reverse         数组翻转
 join            数组转成字符串
 indexOf         数组元素索引
 slice           切取数组,原数组不发生变化
 splice          剪接数组,原数组变化,可以实现前后删除效果
 concact         数组合并
      //添加元素到最后
      arr.push("c");
      //添加元素到最前
     arr.unshift(0);
     //删除最后一项
     arr.pop();
     //删除第一项
     arr.shift();
     //数组翻转
     var arr2 = arr.reverse();
     //数组转成字符串
     //arr.join(",");
     
     //数组元素索引
     var index = arr.indexOf("a");
     //切取数组,原数组不发生变化
     var arr3 = arr.slice(0,3); // [  )
     //剪接数组,原数组变化,可以实现前后删除效果
     var arr4 = arr.splice(1,3,"aa","bb");
     //concact           数组合并
     var arr5 = [12345,67890];
     var arr6 = arr.concat(arr5);

2.9函数(**)

函数,即方法。就是一段预先设置的功能代码块,可以反复调用,根据输入参数的不同,返回不同的值。函数也是对象。

2.9.1.函数的定义

函数有三种定义方式:函数声明语句,函数定义表达式,Function构造函数

【函数声明语句】

 function 函数名([参数列表]){
 ​
 }
 如:
     function test(){
         console.log("函数声明语句!");
     }
     test();// 调用函数
     
     function test2(a){
         console.log(a);
     }
     test2(123);

该种函数定义方式具有函数名提升效果

 test();
 function test(){
     console.log("函数声明语句!");
 }
 test();// 调用函数

【函数定义表达式】

 // var 变量名 = function([参数列表]){}
         
     var test = function(){
         console.log("函数定义表达式");
     }
     test();
     
     var test2 = function(a){
         console.log(a);
     }
     test2(123);

【Function构造函数】了解即可

Function构造函数接受任意数量的参数,但最后一个参数始终都被看成函数体,而前面的参数则列举出了新函数的参数。

   var add = new Function('a','b','return(a+b)') ;
  等价于:
  function add(x,y){
     return x + y;
  }
  add();
 

注:在JS中没有方法重载,如果函数名相同则方法被覆盖。

2.9.2.函数的参数,调用和return语句

2.9.2.1.函数的参数

函数运行时,有时候需要提供外部数据,不同的外部数据会得到不同的结果,这种外部数据叫做参数,定义时的参数为形参,调用时的参数为实参。

  • 实参可以省略,那么对应的形参为undefined

  • 若函数形参同名(一般不会这样做):在使用时以最后一个为准

  • 可以给参数默认值:当参数为默认值时,可以赋予默认值

  • 参数为值传递,传递副本;引用传递时传地址,操作的是同一个对象

 <script type="text/javascript">
 ​
 //实参可以省略,那么对应的形参为undefined
 function fn(str){
     console.log(str);
 }
 fn();// 不传参数 undefined
 ​
 //若函数形参同名(一般不会这样做):在使用时以最后一个为准
  function fn2(a,a){
      console.log(a);
  }
  fn2(1,2);// 2
  
  //可以给参数默认值:当参数为默认值时,可以赋予默认值
  function fn3(a){
      a=a || "a";
      return a;
  }
  var x = fn3();
  console.log(x); // a
  var x2 = fn3(100); // 100
  console.log(x2);
 ​
 // 参数为值传递,传递副本,原变量值不变
 var n = 10;
 function fn4(num){
     num = 20;
 }
 fn4(n);
 console.log(n); // 10 n不变
 ​
 // 引用传递时传地址,操作的是同一个对象
 var obj = {
     uname:"小明",
     password:"123456"
 };
 ​
 function fn5(o){
     o.uname = "小蓝";// 修改对象中的属性值
 }
 fn5(obj);
 console.log(obj);// {uname: "小蓝", password: "123456"} 改变了
     
 </script>
2.9.2.2.函数调用

函数的调用有三种方式:

  1. 常用调用方式: 函数名([参数列表])

  2. 函数调用模式:

  3. 对象调用模式

 <script type="text/javascript">
     // 函数调用模式
     function add(x,y){
         return x+y;
     }
     var ans = add(10,20);
     console.log(ans);
     
     //对象调用模式
     var obj = {
         uname:"小明",
         password:"123456",
         age:18,
         sex:true,
         test:function(){
             console.log("对象调用模式");
         }
         
     };
     obj.test();
     
         
 </script>
2.9.2.3函数的返回
  1. 如果函数有返回值,则需要通过return返回

  2. 如果函数不需要返回数据时,则无返回值,或者说返回undefined

  3. 如果函数不需要返回值时,使用return,则表示结束方法

作用:

  1. 返回结果给调用者

  2. 结束语句

2.10.内置对象

 Arguments   只在函数内部定义,保存了函数的实参
 Array           数组对象
 Date            日期对象,用来创建和获取日期
 Math            数学对象
 String          字符串对象,提供对字符串的一系列操作
2.10.1.String
 chartAt(index)      返回指定位置处的字符
 indexOf(Chr)        返回指定子字符串的位置,从左到右,找不到返回-1
 substr(m,n)         返回给定字符串中从m位置开始,取n个字符,如果参数n省略,则意味着取到字符串末尾
 substring(m,n)      返回给定字符串中从m位置开始,到n位置结束,如果参数n省略,则意味着取到字符串末尾
 toLowerCase()       将字符串中的字符全部转换为小写
 toUpperCase()       将字符串中的字符全部转换为大写
 length()            属性,不是方法,返回字符串的长度

 

2.10.2.Math
 Math.random()       随机数
 Math.ceil()         向上取整,大于最大整数
 Math.floor()        向下取整,小于最小整数String
 例子: 
     console.log(Math.random()); // 生产随机数
     var num = 1.4;
     console.log(Math.ceil(num)); // 2
     console.log(Math.floor(num)); // 1
2.10.3.Date

2

   
     let date = new Date(); // 获取当前日期与时间
     date.getFullYear(); //获取完整的年份(4位)
     date.getMonth() + 1; //获取当前月份(1-12)
     date.getDate(); //获取当前日(1-31)
     date.getDay(); //获取当前星期X(0-6,0代表星期天)
     date.getTime(); //获取当前时间(从1970.1.1开始的毫秒数)
     date.getHours(); //获取当前小时数(0-23)
     date.getMinutes(); //获取当前分钟数(0-59)
     date.getSeconds(); //获取当前秒数(0-59)
     date.getMilliseconds(); //获取当前毫秒数(0-999)
     
     date.toLocaleString(); //将本地时间转成字符串
 
 date.setDate()  //设置Date对象中月的某一天(1 ~31)
 date.setFullYear()  //设置Date对象中的年份(四位数字)
 date.setMonth() //设置Date对象中月份(0 ~11)
 date.setTime()  //设置Date对象的时间
 date.setHours() //设置Date对象中的小时(0 ~23)
 date.setMinutes() //设置Date对象中的分钟(0 ~59)
 date.setSeconds() //设置Date对象中的秒钟(0 ~59)
 date.setMilliseconds() //设置Date对象中的毫秒(0 ~999)

2.11.对象(**)

JavaScript中的对象其实就是生活中对象的一个抽象 JavaScript的对象是无序属性的集合。 其属性可以包含基本值、对象或函数。对象就是一组没有顺序的值。我们可以把JavaScript中的对象想象成键值对,其中值可以是数据和函数。 对象的行为和特征 特征---属性 行为---方法

2.11.1.对象的创建

Js创建自定义对象,主要通过三种方式:字面量形式创建对象(最常用)、通过new Object对象创建、通过Object对象的create方法方法创建对象。

【字面量形式创建】

 var 对象名 = {};//创建了一个空的对象
 var 对象名 = {键:值,键2:值2....};//
 赋值:对象名.键 = 值 (如果键存在,则表示修改数据;如果键不存在,则表示添加数据)

【参考代码】

 <script type="text/javascript">
 ​
 var obj = {}; // 空对象
 console.log(obj);
 obj.name = "小明";
 obj.age = 18;
 console.log(obj);//{name: "小明", age: 18}
 // 非空对象 (键都是字符串,值可以是六种数据类型中的任意一种)
 ​
 var obj2 = {
     uname:"小红",// 字符串
     uage:18,// 数值
     islike:true,// 布尔值
     hello:function(){// 函数
         console.log("hello world!")
     },
     pets:["cat","dog"],// 数组
     dog:{// 对象
         name:"旺财",
         age:2,
     }
 };
 console.log(obj2);
 console.log(obj2.uname);
 obj2.hello(); // 方法调用
 console.log(obj2.dog.name);
 ​
 </script>

注:键都是字符串,值可以是六种数据类型中的任意一种

【通过new Object创建】

var 对象名 = new Object();// 创建一个空的对象

 var obj = new Object();
 obj.name = "小明";
 obj.age = 18;
 console.log(obj);

【过Object对象的create方法方法】

var 对象名 = Object.creat(null);

 var obj = Object.creat(null);
 obj.name = "小红";
 obj.age = 19;
 console.log(obj);

2.11.2.对象的序列化和反序列化

序列化即将JS对象序列化为字符串,反序列化即将字符串反序列化为JS对象。JS中通过调用JSON方法,可以将对象序列化为字符串,也可以将字符串反序列化为对象。

【序列化对象,把对象序列化为字符串】

 JSON.stringify(object);

【反序列化,将一个JSON字符串转换位对象】——常用操作

 JSON.parse(jsonStr);

【参考代码】

 <script type="text/javascript">
 ​
 var obj1 = {
     uname:"小红",// 字符串
     uage:18,// 数值
     islike:true,// 布尔值
     hello:function(){// 函数
         console.log("hello world!")
     },
     pets:["cat","dog"],// 数组
     dog:{// 对象
         name:"旺财",
         age:2,
     }
 };
 ​
 console.log(obj1);
 //序列化对象,把对象序列化为字符串
 var str = JSON.stringify(obj1);
 console.log(str);
 ​
 //反序列化,将一个JSON字符串转换位对象
 var obj2 = JSON.parse(str);
 console.log(obj2);
 console.log(obj2.uname);
 ​
 </script>

3.11.3.this

this是Javascript中的一个关键字。

他代表函数运行时,自动生成一个内部对象,只能在函数内部使用。

随着函数使用场合的不同,this的值会发生变化。但是有一个总的规则,那就是this指的是,调用函数的那个对象。

【在函数中使用this】

在函数中使用this属于全局性调用,代表全局对象,通过window对象来访问。

【在对象中使用this】

在对象中的函数使用this,代表当前的上级对象

 var obj = {
     name:"zhangsan",
     age:20,
     sayHello:function(){
         console.log(this.name);
         console.log(this.name);
     }
 };
 ​
 obj.syaHello();
 // 谁调用的函数就指向谁

 

这篇关于Javascript基础的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!