当前位置:Gxlcms > JavaScript > JavaScript比较冷门的知识点

JavaScript比较冷门的知识点

时间:2021-07-01 10:21:17 帮助过:7人阅读

原生函数

  常用的原生函数

    String()

    Number()

    Boolean()

    Array()

    Object()

    Function()

    RegExp()

    Date()

    Error()

    Symbol()

  内部属性 [Class]

    所有typeof 返回值为object 的对象都包含一个内部属性[Class],这个属性无法直接访问,一般通过Object.prototype.toString(..) 来看。

      例如:

        Object.prototype.toString.call([1,2,3]);

          // "[object Array]"

    基本类型值

        Object.prototype.toString.call(null);

          // "[object Null]"

    封装对象包装

        由于基本类型值没有.length .toString() 这样的属性和方法。

    封装对象释疑

      想要自行封装基本类型值,可以使用Object(..)(不带new 关键字)

        var a = "abc";

        var b = new String(a);

        var c = Object(a);

          一般不推荐直接使用封装函数

    拆封

      封装对象中的基本类型值,可以使用valueOf() 函数。

        var a = new String("abc");

        var b = new Number(42);

        var c = new Boolean(true);

        a.valueOf(); // "abc"

        b.valueOf(); // 42

        c.valueOf(); // true

    原生函数作为构造函数

        Array(..)

        var a = new Array(1,2,3);

          a; // [1,2,3]

        var b = [1,2,3]

          b; // [1,2,3]

      构造函数Array(..),不要求必须带关键字new,不带时他会自动补上Array构造函数只带一个参数时候,该参数会被数组的预设长度而不是当数组中的一个元素。

        var a = new Array(3);

          a.length; // 3

          a;

        总之永远不要创建和使用空单元数组

    Object(..) , Function(..) , RegExp(..)

        除非万不得已,否则不要使用Object(..) / Function(..)/ RegExp(..)

    Date(..) Error(..)

      创建时间必须使用 new Date(),主要是用来获取当前的Unix 时间戳Date.new()然后通过日期对象中的getTime() 来获得。

     创建错误对象(error objec) 主要是为了获得当前运行的上下文。

    Symbol(..)

      基本数据类型——符号。符号具有唯一性的特殊值,用它来命名属性不容易导致重名。

      Symbol 的静态属性形式,Symbol.create, Symbol.iterator

         obj[Sybol.iterator] = function() {/*..*/}

        使用 Symbol(..) 原生构造函数来自定义符号,不能带new 关键字,否则报错。

          var mysym = Symbol("my own symbol");

            mysym; // Symbol(my own symbol)

            mysym.toString(); // "Symbol(my own symbol)"

            typeof mysym; // "symbol"

            var a = { };

            a[mysym] = "foobar";

            Object.getOwnPropertySymbols(a);

             // [Symbol(my own symbol)]

  原型类型

      原生构造函数有自己的 .prototype对象 如: Array.prototype,

        String.prototype.

        String#indexOf(..)

       在字符串中查找指定字符串的位置。

        String#charAt(..)

       获得字符串指定位置上字符

        String#substr(..),String#substring(..) String# slice(..)

      获取字符串的指定部分

        String#toUpperCase() String#toLowerCase()

      将字符串转换为大写和小写

        String#trim()

      去掉字符串前后的空格,返回新的字符串

    强制类型转换

      值的类型转换

          将值从一种类型转换为另一种类型转换,这是显示的情况,隐式的情况通常为强制类型转换。

          JavaScript 中的类型转换总是是返回标量基本类型。

      抽象值操作

        ToString

          抽象操作ToString ,它负责处理非字符串到字符串的强制类型转换数组的默认toString() 方法经过重新定义,将所有的单元字符串化以后在连接在一起。

            var a = [1,2,3];

            a.toString(); // "1,2,3"

        JSON字符串换,

          JSON.stringify(..) 在对象中遇到undefined,function symbol 时会自动将其忽略,在数组中则会返回null

            例如:

              JSON.stringify(undefined); // undefined

              JSON.stringify(function(){}); // undefined

              JSON.stringify(

                  [1,undefined,function(){},4]

                ); // "[1,null,null,4]"

              JSON.stringify(

                {a:2,b:function(){}}

              ); // "{"a":2}"

         toJSON() 返回的应该是一个适当的值,可以是任何类型,然后再由JSON.stringify(..) 对齐进行字符串化。

      ToNumber

        有时候需要将非数字值当做数字来使用,比如数学运算。

          true 转为 1false 转换为 0 ,undefined 转换为NaN

          null 转换为0

        为了将值转换为相应的基本类型,抽象操作ToPrimitive ,首先检查该值是否valueOf() 方法,如果有就用该值进行强制类型转换。没有就用toString()

        的返回值来进行强制类型转换。如果valueOf() toString() 均不会返回值就会产生TypeError 错误。

    ToBoolean

       假值:

        值可以被分为以下两类。

          1.可以被强制类型转换为false的值

          2.其他(被轻质类型转换为true的值)

        以下这些是假值

undefined

null

false

+0,-0NaN

""

        假值对象:浏览器在某些特定情况下,在常规JavaScript语法基础上创建了一些外来值,这些就是假值对象

      真值

        真值就是假值列表以外的值

      显式强制类型转换

        字符串和数字之间的显示转换

        字符串和数字之间显示强制类型转换是通过String(..) Number(..).

        两者之间的显式强制类型转换

var a = 42;

var b = String(a);

var c = "3.14";

var d = Number(c);

b; // "42"

d: // 3.14

       还有其它方式实现字符串和数字之间的显示转换

var a = 42;

var b = a.toString();

var c = "3.14";

var d = +c;

b; // "42"

d: // 3.14

    日期显示转换为数字

一元运算符+ 的另一个常见的用途是将日期对象(Date)对象强制转换为数字。

        var timestamp = +new Date();

    显式解析数字字符串

      解析字符串中的数字和将字符串强制类型转换为数字的返回结果都是数字。

        例如:

var a = "42";

var b = "42px";

Number(a); // 42

parseInt(a); // 42

Number(b); // NaN

parseInt(b); // 42

        解析允许字符串中含有非数字字符,解析按从左到右的顺序,如果遇到非数字字符就停止。

        parseInt(..) 针对的是字符串,像parseInt(..) 传递数字和其他类型的参数是没用的

    显示转换为布尔值

      ToBoolean 是显式的ToBoolean 强制类型转换:

var a = "0";

var b = [];

var c = {};

var d = "";

var e = 0;

var f = null;

var g;

Boolean(a); // true

Boolean(b); // true

Boolean(c); // true

Boolea(d); // false

Boolea(e); // false

Boolea(f); // false

Boolea(g); // false

      一元运算符!显示地将值强制类型转换为布尔值。

var a = "0";

var b = [];

var c = {};

var d = "";

var e = 0;

var f = null;

var g;

!!a; // true

!!b; // true

!!c; // true

!!d; // false

!!e; // false

!!f; // false

!!g; // false

    隐式强制类型转换

      隐式地简化

        字符串和数字之间的隐式强制类型转换

        +运算符既能用于数字加法,也能用于字符串拼接。

var a = "42";

var b = "0";

var c= 42;

var d = 0;

a + b; // "42"

c + d; // 42

        对象的 - 操作与 + 类似;

var a = [3];

var b = [1];

a - b ; // 2

      布尔值到数字的隐式强制类型转换

      隐式强制类型转换为布尔值

      下面的情况会发生隐式强制类型转换

1.if(..) 语句中的条件判断表达式。

2.for(..;...;..)语句中的条件判断表达式(第二个)

3.while(..) do..while(..) 循环中的条件判断表达式。

4.? : 中的条件表达式

5.逻辑运算符 || (逻辑或) (逻辑与) 左边的操作数(作为条件判断表达式)

      || &&

|| && 运算符 的返回值并不一定是布尔类型,而是两个操作数其中的一个的值

var a = 42;

var b = "abc";

var c = null;

a || b; // 42

a && b; // "abc"

c || b; // "abc"

c&& b; // null

对于 || 来说 如果条件判断结果为true 就返回第一个数的值,如果为false 就返回第二个操作数。

&& 则相反。

下面是一个|| 十分常见的 || 用法。

function foo(a,b){

a = a || "hello";

b = b || "world";

console.log(a + " " + b );

}

foo(); // "hello world"

foo("yeah","yeah"); // "yeah yeah"

符号的强制类型转换

        宽松相等和严格相等

          “== 允许在相等比较中进行强制类型转换, 而=== 不允许

        抽象相等

          有几个非常规的需要注意

NaN 不等于NaN

+0 等于-0

宽松不相等 != 就是==的相反, !== 同理

          字符串和数字之间的相等比较

1.如果Type(x) 是数字,Type(y)是字符串,则返回 x== ToNumber(y)

的结果。

2.如果Type(x) 是字符串,Type(y) 是数字,则返回 ToNumber(x)== y 的结果。

      其他类型和布尔类型之间的相等比较

       == 最容易出错的地方就是true false 与其他类型之间的相等比较

var a = "42";

var b = true;

a == b; // false

1.如果Type(x) 是布尔类型,则返回ToNumber(x) == y 的结果

2.如果Type(y) 是布尔类型,则返回 x == ToNumber(y) 的结果

          首先:

var x = true;

var y = "42";

x == y; // false

反过来

var x = "42";

var y = false;

x == y; // false

          null undefined 之间的相等比较

          null undefinded 之间的 == 也涉及隐士强制类型转换。

1.如果 x null ,y undefined ,则结果为 true

2.如果x undefined, y null, 则结果为 true

var a == null;

var b;

a == b; // true

a == null; // true

b == null; // true

a == false; // false

b == false; // false

a == "" ; // false

b == ""; // false

a == 0; // false

b == 0; // false

    对象和非对象之间的相等比较

        关于对象和(对象/函数/ 数组) 和标量基本类型(字符串/数字/布尔值)之间的比较。

1.如果Type(x) 是字符串或数字,type(y)是对象,则返回 x == ToPrimitive(y) 的结果

2.如果Type(x) 是对象, Type(y)是字符串或数字,则返回

      ToPromitive(x) == y 的结果。

var a = 42;

var b = [42];

a == b; // true

var a = "abc";

var b = Object(a); // new String(a) 一样

a === b; // false

a == b; // true

            a == b 结果为true,应为b 通过ToPromitive 进行强制类型转换,并返回基本类型值 “abc”,与 a 相等。

      假值相等的比较

        一下是常规和非常规的比较

"0" == null; // false

"0" == undefined; // false

"0" == false; // true -- 晕!

“0” == NaN; // false

"0" == 0; // true

"0" == ""; // false

false == null; // false

false == undefined; // false

false == NaN; // false

false == 0; // true -- 晕!

false == "" // true -- 晕!

false == [] // true -- 晕!

false == {} // false

"" == null; // false

"" == undefined; // false

"" == NaN; // false

"" == 0; // true -- 晕!

"" == []; // true -- 晕!

"" == {}; // false

0 == null; // false

0 == undefined; // false

0 == NaN; // false

0 == []; true -- 晕!

0 == {}; false

          因为他们属于假阳。

      极端情况

          [] == ![] // true

      对布尔值进行强制类型转换 [] == ![] 变成 [] == false,

           2 == [2]

          "" == [null]; //true

42 == "43" // false

"foo" == 42; // false

"true" = '"" // false

42 == "42" // true

"foo" == ["foo"] // true

      安全运用隐式强制类型转换

1.如果两边的值中有true 或者 false, 千万不要使用 ==.

2.如果两边的之中有[],"" 或者 0 ,尽量千万不要使用==.这时候最好使用 === 来避免强制类型的转换。

      抽象关系比较

        双方都是字符串比较

var a = ["42"];

var b = ["043"];

a < b; // false

a b 并没有被准换为数字,因为ToPrimitive 返回的是字符串,

比较的是 "42 " "043" 两个字符串, 因为"0"在字母顺序上小于

“4”,所以最后结果为 false.

      同理

var a = [4,2];

var b = [0,4,3];

a < b; // false

a 被转为 “4,2”b 转为 “0,4,3” 同样式按字母顺序进行比较的。

var a = {b: 42};

var b = {b:43};

a < b ; // false

a [object Object], b也是 [object Object] 所以按着字母顺序

a < b 不成立。

    下面的例子

var a = {b: 42};

var b = {b:43};

a < b; // false

a == b; // false

a > b; // false

a <= b; // true

a >= b; // true

以上就是JavaScript比较冷门的知识点的详细内容,更多请关注Gxl网其它相关文章!

人气教程排行