React Native爱你所爱我爱编程

JS基础学习（一）

2017-02-23  本文已影响546人  寒桥

词法结构
类型、值和变量

词法结构

类型、值和变量

1.原始类型（primitive type）
数字、字符串、布尔值、null（空）、undefined（未定义）
2.对象类型（object type）
对象、数组、函数、日期类、正则类、错误类

Math.pow(2,53) // =>9007199254740992：2的53次幂
Math.round(.6) // =>1.0：四舍五入
Math.ceil(.6) // =>1.0：向上取整
Math.floor(.6) //=>0： 向下取整
Math.abs(-5) //=>5：求绝对值
Math.max(x,y,z) // 返回最大值
Math..min(x,y,z) // 返回最小值
Math.random() //生成一个大于0小于1.0的伪随机数
Math.PI//π：圆周率
Math.E // e：自然对数的底数
Math.sqrt(3) // 3的平方根
Math.pow(3,1/3) // 3的立方根
Math.sin(o) // 三角函数：还有Math.cos，Math.atan等
Math.log(10) // 10的自然对数
Math.log(100)/Math.LN10 // 以10为底100的对数
Math.log(512)/Math.LN2 // 以2为底512的对数
Math.exp(3) // e的3次幂

var zero = 0; // 正常的零值
var negz = -0; // 负零值
zero === negz; // => true: 正零值和负零值相等
1/zero === 1/negz // =>false: 正无穷大和负无穷大不等

// 数字具有足够的精度,并可以极其近似于0.1.但事实上,数字不能精确表述带来了一些问题
    var x = .3 -.2;
    var y = .2 -.1;
    console.log(x);  // 0.9999999999998
    console.log(y); // 0.1
    console.log(x==y); // false
    console.log(x==.1); // false
    console.log(y==.1); //true

1.null是JS的关键字，表示一个特殊值，常用来描述“空值”，对null执行typeof预算，结果返回
“object”，也就是说，可以将null认为是一个特殊的对象值，含义是“非对象”。但实际上，通常
认为null是它自有类型的唯一一个成员，它可以表示数字、字符串和对象是“无值”的。

2.undefined未定义来表示更深层次的“空值”。它是变量的一种取值，表明变量没有初始化，如果
要查询对象属性或数组元素的值时返回undefined则说明这个属性或者元素不存在。如果函数没有
返回值，则返回undefined。引用没有提供实参的函数形参的值也只会得到undefined。
undefined是预定义的全局变量（它和null不同，它不是关键字），它的值就是“未定义”。
在ECMAScript 5中是只读的。使用typeof云素服得到undefined的类型，返回的是
“undefined”，表明这个值是这个类型的唯一成员。

3.尽管null和undefined是不同的，但它们都表示“值的空缺”，两者往往是可以互换的。判断相等
运算符“==”认为两者是相等的(要使用严格相等运算符“===”来区分它们)。在希望是布尔类型的地
方它们的值都是假值，和false类似。null和undefined都不包含任何属性和方法。实际上，使用
“.”和“[]”来存取这两个值的成员和方法都会产生一个类型错误。如果想将它们赋值给变量或者属性
，或将它们作为参数传入函数，最佳选择是使用null。

全局属性，比如undefined、Infinity和NaN
全局函数，比如isNaN()、parseInt()、eval()
构造函数，比如Date()、RegExp()、String()、Object()和Array()
全局对象，比如Math和JSON

var s = "test";
s.len = 4;
var t = s.len;

当运行这段代码时，t的值是undefined。第二行代码创建了一个临时字符串对象，并给其len属性赋值为4，随即销毁这个对象。第三行通过原始的（没有修改过）字符串值创建一个新字符串对象，尝试读取len属性，这个属性自然是不存在的，表达式求值结果是undefined。这段代码说明了在读取字符串、数字和布尔值的属性值（或方法）的时候，表现的像对象一样。但如果你试图给其属性赋值，则会忽略这个操作：修改只是发生在临时对象身上，而这个临时对象并未继续保留下来。

var s = "test", n = 1, b = true; // 一个字符串、数字和布尔值
var S = new String(s); // 一个字符串对象
var N = new Number(n); // 一个数值对象
var B = new Boolean(b); // 一个布尔对象

JS会在必要时将包装对象转换成原始值，因此上段代码中的对象S、N和B常常但又不总是表现的和s、n和b一样。“==”等于运算符将原始值和其包装对象视为相等，但“===”全等运算符将它们视为不等。通过typeof运算符可以看到原始值和其包装对象的不同。

var string1 = "hehe";
var string2 = "hehe";
string1 == string2; // => true
string1 === string2; // => true

    // 具有相同属性的两个对象
    var object1 = {x:1};
    var object2 = {x:1};
    object1 == object2; // false: 两个单独的对象永不相等
    object1 === object2; // false: 两个单独的对象永不相等
    alert(object1 === object2);

    // 具有相同元素的两个数组
    var array1 = [1,2];
    var array2 = [1,2];
    array1 == array2; // false: 两个单独的数组永不相等
    array1 === array2; // false: 两个单独的数组永不相等

我们通常将对象称为引用类型（reference type），以此来和JS的基本类型区分开来。对象值都是引用，对象的比较均是引用的比较；当且仅当它们引用同一个基对象时，它们才相等。

    var a= []; // 顶一个引用空数组的变量a
    var b = a; // 变量b引用同一个数组
    b[0] = 1;  // 通过变量b来修改引用的数组
    a[0]       // => 1: 变量a也会修改
    a === b    // => true: a和b引用同一个数组,因此它们相等

上边代码中，将对象（数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。如果想得到一个对象或者数组的副本，则必须显示复制对象的每个属性或数组的每个元素。下面例子则是通过循环来完成数组的复制

    var a = ['a', 'b', 'c']; // 待复制的数组
    var b = [];              // 复制到的目标空数组
    for (var i = 0; i < a.length; i++) {
        b[i] = a[i];
    }
    alert(b);  // => ['a', 'b', 'c']

同样的如果相比较两个单独的对象或者数组，则必须比较他们的属性或元素。下边代码比较两个数组的函数

    function equalArrays(a, b) {
        if (a.length != b.length) return false;
        for (var i = 0; i < a.length; i++) {
            if (a[i] != b[i]) return false;
        }
        return true;
    }

10 + "objects"  // =>"10 objects" 数字10转换成字符串
"7" * "4"       // =>28: 两个字符串均转换成数字
var n = 1 - "x" // =>NaN:字符串“x”无法转换为数字
n + "objects"   // =>"NaN objects": NaN转换成字符串“NaN”
值 转字符串 转数字 转布尔值 转对象
undefined "undefined" NaN false throws TypeErrow
null "null" 0 false throws TypeErrow
true "true" 1 new Boolean(true)
false "false" 0 new Boolean(false)
''"(空字符串) 0 false new String("")
"1.2"(非空，数字) 1.2 true new String("1.2")
"one"(非空，非数字) NaN true new String("one")
0 "0" false new Number(0)
-0 "0" false new Number(-0)
NaN "NaN" false new Number(NaN)
Infinity "Infinity" true new Number(Infinity)
-Infinity "-Infinity" true new Number(-Infinity)
1(无穷大，非零) "1" true new Number(1)
{}(任意对象) 下文有解释 下文有解释 true
[]'(任意数组) "" 0 true
[9]'(1个数字元素) "9" 9 true
['a']'(其他数组) 使用join()方法 NaN true
function(){}(任意函数) 下文有解释 NaN true

原始值到对象的的转换很简单，原始值通过调用String()、Number()或Boolean()构造函数，转换为它们各自的包装对象。null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常，而不会执行正常的转换

下面的比较结果都是true
null == undefined  // 这两值被认为相等
"0" == 0 // 在比较之前字符串转换成数字
0 == false // 在比较之前布尔值转换成数字
"0" == false // 在比较之前字符串和布尔值都转换成数字
注："=="等于运算符在判断两个值是否相等时做了类型转换，而"==="恒等运算符在判断相等时并未做任何类型
转化

需要注意的是，一个值转换成另外一个值并不意味着两个值相等。比如如果在期望使用布尔值的地方使用了undefined，它将转换成false，但这并不意味着undefined==false

var n = 17;
binary_string = n.toString(2); // 转换为"10001"
octal_string = n.toString(8); // 转换为"021"
hex_string = n.toString(16); // 转换为"0x11"

var n = 123456.789;
// toFixed()根据小数点后指定位数将数字转换成字符串
n.toFixed(0); // "123457"
n.toFixed(2); // "123456.79"
n.toFixed(5); // "123456.78900"
// toExponential()使用指数计数法将数字转换为指数形式的字符串,其中小数点前只有一位,小数点后的位数
由参数决定
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
// toPrecision()根据指定有效数字位数将数字转换成字符串
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"
n.toPrecision(10); // "123456.7890"

parseInt("3 blind mice")  // 3
parseFloat("   3.14 meters")  // 3.14
parseInt("-12.34")  // -12
parseInt("0xFF")  // 255
parseInt("0xff")  // 255
parseInt("-0xFF")  // -255
parseFloat(".1")  // 0.1
parseInt("0.1")  // 0
parseInt(".1")  // NaN  整数不能以“.”开头
parseFloat("$72.67")  // NaN 数字不能以"$"开始

parseInt()可以接收第二个参数，这个参数指定数字转换的基数

parseInt("11", 2) // 3(1*2+1)
parseInt("ff", 16) // 255(15*16+15)
parseInt("zz", 36) // 1295(35*36+35)
parseInt("077", 8) // 63(7*8+7)
parseInt("077", 10) // 77(7*10+7)

数组类：[1,2,3].toString()  // => "1,2,3"
数组类的toString()方法将每个数组元素转换成一个字符串，并在元素之间添加逗号后合并成结果字符串

函数类：(function(x) { f(x); }).toString() // =>"function(x) {\n f(x); \n}"
函数类的toString()方法返回这个函数的实现定义的表示方式，转换成JS源代码字符串

日期类：new Date(2010,0,1).toString() // =>"Fri Jan 01 2010 00:00:00 GMT-0800(PST)"
日期类的toString()方法返回一个可读的日期和时间字符串

RegExp类：/\d+/g.toString() // => "/\\d+/g"
RegExp类的t0String()方法将RegExp对象转换成表示正则表达式直接量的字符串

var d = new Date(2010, 0, 1); // 2010年1月1日（太平洋时间）
d.valueOf()  // => 1262332800000

var truevar = 1; // 声明一个不可删除的全局变量
fakevar = 2; // 创建全局对象的一个可删除的属性
this.fakevar2 = 3; // 同上
delete truevar; // =>false:变量并没有被删除
delete fakevar; // =>true:变量被删除
delete this.fakevar2; // =>true:变量被删除
上一篇 下一篇

猜你喜欢

热点阅读