初始引用值

  • 数组
  • 对象

数组

数组对象用来在单独的变量名中存储一系列的值。形式是一个中括号,里面可以写很多东西,中间用逗号隔开,每个逗号类似可以隔开两个仓库,每个仓库可以放东西,比如 Number、String 、undefined，放什么类型的值都可以。

  1. var arr = [1,2,undefined,"abc",["a",1,5],null]
  2. // 数组的增加
  4. document.write(arr.push("吴彦祖"));
  5. // 打印arr-->[1,2,undefined,"abc",["a",1,5],null,"吴彦祖"]
  7. // 数组的删除(还有多种方法)
  8. arr.splice(0,1);
  9. // 打印出来是[2,undefined,"abc",["a",1,5],null]
  12. // 数组的修改
  13. arr[0];                //打印出来是0
  14. arr[0] = 100;    //在打印出来就是100;
  16. // 数组的查看
  17. for(var i = 0;i<arr.length;i++)
  18. console.log(arr[i]);
  19. // 打印出对应于的值

关于数组的其他方法

  • For…In 声明
    使用 for…in 声明来循环输出数组中的元素。
  • 合并两个数组 - concat()
    如何使用 concat() 方法来合并两个数组。
  • 用数组的元素组成字符串 - join()
    如何使用 join() 方法将数组的所有元素组成一个字符串。
  • 文字数组 - sort()
    如何使用 sort() 方法从字面上对数组进行排序。
  • 数字数组 - sort()
    如何使用 sort() 方法从数值上对数组进行排序。

对象

JavaScript 对象是拥有属性和方法的数据。JavaScript 中的所有事物都是对象：字符串、数字、数组、日期，等等。在 JavaScript 中，对象是拥有属性和方法的数据。

  1. var obj = {
  2.     key : value,
  3.     键 : 值,
  4.     属性: 属性值; 
  5. }
  8. var car = {
  9.     type:"Fiat", 
  10.     model:500, 
  11.     color:"white",
  12.     money:undefined,
  13.     newCar:false,
  14. }
  16. // 增加对象属性
  17. car.width = "1.6m";
  18. // 删除对象属性
  19. delete car.width;
  20. // 修改对象属性
  21. car.width = "1.5m";

typeof

  • 六种数据类型
    • Number
    • string
    • boolean
    • undefined
    • object
    • null
  1. // 语法
  2. typeof("里面放数据")
  4. // 例子
  6. var num = 123;
  7. var str = "123";
  8. var a = true;
  9. var b = null; 
  10. var c = undefined;
  11. console.log(typeof(num));    //打印-->number
  12. console.log(typeof(str));    //打印-->string
  13. console.log(typeof(a));        //打印-->boolean
  14. console.log(typeof(b));        //打印-->object
  15. console.log(typeof(c));        //打印-->undefined
  16. //第二种方法
  17. console.log(typeof c);        //打印-->undefined 空格也可以

类型转换

显示类型转换

  • Number(mix) 转换成数
  • parseInt(string,radix) 转换成整数
  • parseFloat(string) 把数字转换为浮点数
  • toString(radix) 转换成为字符串
  • String(mix) 把内容换成字符串
  • Boolean() 转换成布尔值
  1. //Number转换成数
  2. var num = Number("123");             // 打印123
  3. var num = Number(true);                // 打印1
  4. var num = Number(false);            // 打印0
  5. var num = Number(null);                // 打印0
  6. var num = Number(undefined);    // 打印NaN
  7. var num = Number("a");                // 打印NaN
  8. var num = Number("123abc");        // 打印NaN
  10. // parseInt 转换成整数
  11. // parseInt(String,radix)
  12. // radix 是调整进制取值范围是2-36
  13. // parseInt 是用数字从前往后截，截取到最后一个字符，如果出现非数字，把之前的数字返回（如例子一）
  15. var num = parseInt("123.9");        // 打印123不是四舍五入
  16. var num = parseInt(true);                // 打印NaN
  17. var num = parseInt(false);            // 打印NaN
  18. var num = parseInt(null);                // 打印NaN
  19. var num = parseInt(undefined);    // 打印NaN
  20. var num = parseInt("a");                // 打印NaN
  21. var num = parseInt("123abc");        // 打印123  例子1
  23. // parseFloat 把数字转换为浮点数
  25. var num = parseFloat("123.9");         // 打印123.9
  26. var num = parseFloat(true);                // 打印NaN
  27. var num = parseFloat(false);            // 打印NaN
  28. var num = parseFloat(null);                // 打印NaN
  29. var num = parseFloat(undefined);    // 打印NaN
  30. var num = parseFloat("a");                // 打印NaN
  31. var num = parseFloat("123.2abc");    // 打印123.2
  33. // String把内容换成字符串
  34. var num = String(123.9);                     //打印"123.9"
  35. var num = String(undefined);            //打印"undefined"
  37. // Boolean转换成布尔值
  38. // 除了undefined、null、NaN、""、0、false 打印出来的是false以外, 其他的全是true
  39. var num = Boolean(123.9);                    // 打印 true
  40. var num = Boolean(undefined);            // 打印false
  42. // toString(radix) 转换成为字符串
  43. // 两个不能用一个 undefined 一个 null，会报错 undefined 和 unll没有这个 toString 属性
  44. // radix 是以10进制为基底转换为别的进制
  45. // 用法:要转的数据.toString
  46. var demo = 123;
  47. var str = demo.toString();
  48. console.log(str)                                    // 打印出"123"

隐式内容转换

  • isNaN()
  • ++/— +/-(一元正负)


  • -，*，/，%
  • &&，||，!
  • <，>，<=，>=
  • == !=
  1. //isNaN()当你把数放在括号里面的时候他能判断这个是是不是NaN,然后给你返回回来
  3. console.log(isNaN(NaN));            // 打印true
  5. console.log(isNaN(123));            // 打印false
  7. console.log(isNaN("123"));        // 打印false
  9. console.log(isNaN("adc"));        // 打印true
  11. console.log(isNaN(null);            // 打印false
  13. console.log(isNaN(undefined);    // 打印true
  15. // isNaN 在内部 执行了一个 Number 方法
  16. // 比如 isNaN("abc")
  17. // 首先执行了 Number("abc") 看是不是NaN 如果是就返回 NaN
  18. // 所以这个 Number 它没有显示的去调用，是隐式的去调用
  1. // ++，先调用Number
  2. var a = "123";
  3. a++;        // 打印出a-->124;
  5. var a = "abc";
  6. a++;        // 打印出a-->NaN;
  8. // +/- 先调用Number
  9. var a = + "abc";
  10. console.log(typeof(a))    // 打印出Number
  13. // + 隐式类型转换调用的是string
  14. var a = "1" + 1;
  15. console.log(typeof(a))    //打印出string
  1. //-、*、/、% 隐式类型转换调用的是 Number
  1. // <、>、<=、>= 如果有数字就调用 Number
  2. var a = "1" < 2;
  3. console.log(typeof(a)) // 打印出boolean
  1. // == 、!=
  2. var a = "1" == 1;
  3. console.log(typeof(a))    // 打印出 boolean true
  1. //特殊的
  2. undefined > 0            //打印false
  3. undefined < 0            //打印false
  4. undefined == 0        //打印false
  5. null > 0                    //打印false
  6. null < 0                    //打印false
  7. null == 0                    //打印false
  8. undefined == null    //打印true
  9. NaN == NaN                //不等于任何东西

不发生类型转换

  • === !==(绝对的等于 绝对不等于)
  1. 1 !== "1"     // true
  2. 1 !== 1         // false
  3. NaN === NaN // false

还有一种特殊的

  1. // a 在没有定义的情况下
  2. typeof(a);// 用console.log 打印出 undefined
  5. // typeof返回的值类型 都是 string 类型
  6. typeof(typeof(a))// 用 console.log 打印出 string