javascript(1)

变量

javascript是一种“松散类型的程序设计语言”(Loosely Typed Programming Language),程序变量不需要事先声明就可以直接使用,我们可以将Javascript变量视为一个在程序代码中暂存数据的容器，变量值可以在程序代码中随时使用变量名称读取或者更改变量值

变量声明

Javascript的变量需要使用var或者使用赋值语句来隐藏声明。

####　使用var声明

var strName;  //声明变量
strName = "hello"   //给变量赋值
//也可以直接写成以下形式
var strName = "hello"

var strName = "hello"
strName = 1000 //对strName重新赋值

注：可以使用赋值语句随时更改其数据类型

隐藏声明

strNo = 1234  //没有使用var但在赋值的同时创建了这个变量

数据类型

javascript有6种数据类型：字符串：String 数值：Number 布尔：Boolean 特殊值：Undefined 特殊值：null 对象

基本数据类型

数值(Number)

数值数据类型的变量可以是整数或浮点数
特殊字符串：

• NaN Not a number,当算术表达式的运算结果不是数值类型时，例如字符串或Undefined
• Positive Infinity 数值太大超过javascript正数值范围
• Negative Infinity 数值太大超过Javascript负数值范围
• Positive and Negative 0　javascript用来区分+0和-0

NaN

0/0;  //NaN
Infinity * Infinity; //Infinity
Infinity - Infinity; //NaN
NaN + 16; //NaN
NaN === NaN; //===是严格相等操作符，详情参考下文，false
0/0 === NaN; //false
isNaN(0/0);  //true isNaN可以解读为“不能转换成数值”

注：NaN不等于任何值，甚至不等于NaN

精度的限制

javascript的数值与大多数编程语言一样，受到计算设备固定大小的物理元件的限制，存在精度限制。

0.1 + 0.2 //结果是0.30000000000000004
4.18e-1000 //结果是0

字符串(String)

"javascript"
"'hello' world" //显示为"hello" world

javascript字符串一个很重要的一个特性是不可变，不能对字符串中的字符进行修改，也不能改变字符串的长度。

var s = "hello";
s.toUpperCase(); 
alert(s); //结果仍为hello
//因为第二行只是对原字符串执行了一次转换操作，对结果没有任何影响。

注：toUpperCase()函数作用是将字符串所有字母变成大写的形式
正确写法：

//方法一：直接打印
var s = "hello";
alert(s.toUpperCase());
//方法二：赋值给一个新变量
var s = "hello";
a = s.toUpperCase();
alert(a);

Null

Null数据类型只有一个值null,null是一个关键词不是0，如果变量值为null,表示变量没有值或不再指向任何对象地址。

Undefined

undefined == null, null == undefined  //true,==比较值
undefined === null //false,===比较类型

没有进行赋值的变量。

数据类型转换

弱类型

类型转换结果：

数值

• false被转换成0
• true被转换成1
• 字符串被转换为最可能的数值，如果无法把字符串转成数值，则转换成NaN
• null被转换成0
• undefined被转换成NaN
• 空字符串或完全空白字符构成的字符串被转换成0

布尔值

0、空字符串(“”)、null、undefined、NaN都会被转换成false，其他的都为true

“+”的双重含义

//prompt()方法用于显示一个带有提示信息,并且用户可以输入的对话框。
var x = prompt("Enter a number:");  //输入2
var y = prompt("Enter a number:");  //输入2
alert(x+y);   //结果为22

prompt求值的结果总是字符串，而操作符“+”正好适用于字符串和数值，在上述的代码中“+”体现了字符串连接的功能,(正确计算结果在显示转换中给出)。

注：在javascript中，除了“+”，其他算术运算符均只能用于数值。

显式转换

显示转化的方式

"3.14"-0;  //3.14
"3.14"*1; //3.14
"3.14"/1; //3.14
+"3.14";  //3.14 一元加(速度最快)
Number("3.14");  //3.14
parseFloat("3.14"); //3.14

注：单独的”+”放在数值之前不会产生任何操作，一元减操作符则不同，+4=>4, -4=>-4

var x = +prompt("Enter a number:");  //输入2
var y = +prompt("Enter a number:");  //输入2
alert(x+y); //4

注：解决方法不唯一

数据类型相加

str = "hello"
num = 2019
bln = true
output = str + num  //数值和字符串相加，数值会强制转换成字符串"hello2019"
output = str + bln  //布尔和字符串相加，布尔会强制转换成字符串"hellotrue"
output = num + bln  //布尔和数值相加，布尔会强制转换成数值 2019+1=2020 

注：布尔转换为数值时，true的数值为1，false为0

用函数进行转换

parseInt()

将字符串变量值开头的数值转换成整数，如果字符串没有数值，就返回NaN,在转换时可以指定十六、十和八进制。

parseInt("3 page")   //3
parseInt("3.2")  //3
parseInt("page 3")  //NaN 开头不是数字
parseInt("18ff值",16)   //6399 将字符串转换成16进制

parseFloat()

将字符串变量值开头的浮点数转换成浮点数，如果字符串没有数值，就返回NaN

parseFloat("3.2")   //3.2
parseFloat("page 3")  //NaN

eval()

将表达式的字符串参数当作表达式，函数可以返回表达式的计算结果

eval("20+4*5")  //40
eval("num = 1000")  //1000
eval("5>4")   //true

typeof()

获取变量的数据类型。

var num = 100;
typeof(num)   //number

松散相等操作符

• 严格相等操作符===、!==：当且仅当两个表达式的值相同且类型相同时才返回true。
• 松散相等操作符==、!=：在测试之前会不顾一切地转换数据类型

对象

定义对象

var dress = {
    size:4,  //属性
    color:"red",
    price:200
};
var p ={
    name:{first:"Bob",last:"Li"}
    birth:{year:1999,month:2,day:2}
};

读取属性

定义对象之后，可以使用点或方括号读取属性的值

dress.size  //4
p.name["first"]  //Bob
p["birth"]["year"]  //1999

注：点号访问属性的方式不能读取以整数命名的属性

属性的添加与删除

var dog = {};  //空对象
dog.name = "hei";  //添加属性
dog.breed = "hot";  //dog = {name:"hei",breed:"hot"};
delete dog.breed;  //删除属性 dog = {name:"hei"};

对象引用

对象表达式的值并非对象本身，而是一个指向对象的引用，对象的赋值不会产生新对象。

var a = 8;
var b = {x:1,y:2};
var c = a;
var d = b;

上述代码执行过程演示：

一个对象可以同时被多个变量引用，因此可以通过其中任何一个变量都可以修改对象的属性

var a ={x:1,y:2};
var b = a;
var c = {x:1,y:2};
b.y = 3;
alert(a.y);  //3

上述代码执行过程演示：

对象原型

• 创建一个对象的原型，然后再基于这个原型创建其他对象(相当于面向对象程序设计中的继承)。
• 每个Javascript对象都有一个暗藏的链接指向自己的原型对象。
• 如果你读取的属性不在对象身上，那么Javascript就会进一步查询这个对象的原型对象。。如果在这个原型对象上也没有找到，还会进一步查询原型对象的原型对象，以此类推。
• 如果整个原型链都没有你想读取的属性，就会产生ReferenceError的错误。

  var protoCircle = {x:0,y:0,color:"black"};  //圆的原型对象
  var c1 = Object.create(protoCircle);   //基于protoCircle创建一个c1对象
  c1.x = 4;
  c1.color = "red";   //c1 = {x:4,y:0,color:"red"};
  var c2 = Object.create(protoCircle);  //基于protoCircle创建一个c2对象
  c2.x = 2;
  c2.color = "yellow";   //c2 = {x:2,y:0,color:"yellow"};

注：上例c1\c2属于多个对象共享一个原型

自引用对象

对象的属性可以引用自身，两个对象也可以通过属性互相引用。

var mom ={name:"Alice"};
var dad = {name:"Bob",spouse:mom}
mom.spouse = dad;

数组

数组是一种特殊的对象，它的属性是从0开始的非负整数，还有一个名为length的对应属性。

var a = [1,2,3,4,5];  //a[0]的值为1，a.length()等于5
a[20] = 6; //将a[20]赋值为6,a[5]到a[19]都是Undefined
alert(a.length());  //21
a.length = 50;  //a[21]到a[49]都是Undefined
a.length = 3;  //a = [1,2,3]

数组的方法

####　split()
s.split(分隔符)表示将s以分隔符隔开形成新的数组，分隔符可以为”,”、” “等

var s = ["hello world"];
var a = s.split(" ");  //

slice()

b.slice(n,m)表示将数组b从b[n]切割到bm-1

var b = [1,2,3,4,5,6];
var a = b.slice(2,5);  // a = [3,4,5]
var c = b.slice()  //所有索引，得到b的副本

concat()

将两个数组拼接起来

var a = ["A","hello"];
var b = [1,2,3,4];
var c = a.concat(b);  //c = [1,2,3,4,"A","hello"];

join()

把数组元素连接起来可以创建一个由同一个分隔符分隔的字符串。

var a = [1,2,4,"hello"];
alert(a.join("**"));  //[1**2**4**hello]

可变操作

可以修改数组本身的操作称为可变操作

push()\unshift()

push()在数组末尾添加元素,unshift()在数组开头添加元素

var b = [1,2];
b.push(3) ;  //b = [1,2,3]
b.unshift(0);  // b = [0,1,2,3]

pop()\shift()

pop()在数组末尾删除元素，shift()在数组开头删除元素

var a = [1,2,3,4];
a.pop();  // a=[1,2,3]
a.shift();  //a=[2,3]

sort()

对数组元素进行排序

var a = [7,3,5,2,10,1];
a.sort();  //a = [1,10,2,3,5,7],字符串10小于2

注：javascript默认是将所有数组元素都当成字符串来排序。

reverse()

反转数组元素的顺序

filter()

• 创建一个数组，其中填充了通过测试（作为函数提供）的所有数组元素。
• 不为没有值的数组元素执行函数
• 不更改原始数组

map()

• 方法的作用是：创建一个新数组，并为每个数组元素调用一个函数。
• 按顺序为数组中的每个元素调用提供的函数一次。
• 此方法不会更改原始数组

reduce()

• 接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
• 函数的返回值存储在累加器中（result/total）