react-native学习二--javaScript一下午快速入手

 

介绍      JavaScript 是一种多范式的动态语言，它包含类型、运算符、标准内置（ built-in）对象和方法。它的语法来源于 Java 和 C，所以这两种语言的许多语法特性同样适用于 JavaScript。JavaScript 通过原型链而不是类来支持面向对象编程。（我觉得最后一句是废话）

时间宝贵---开整

一基本类型，看一眼就行

• Number（数字）JavaScript 不区分整数值和浮点数值
• String（字符串）一串Unicode 字符序列，一串UTF-16编码单元的序列，每一个编码单元由一个 16 位二进制数表示，使我们日常开发用到最多的类型，啥也不应管，用到再撸。
• Boolean（布尔）用到再撸
• Symbol（符号）（ES2015 新增）用到再撸
• Object（对象）用到再撸
  • Function（函数）
  • Array（数组）注意，Array.length 并不总是等于数组中元素的个数，如下所示：

    var a = ["dog", "cat", "hen"];
    a[100] = "fox";
    a.length; // 101

  • Date（日期）
  • RegExp（正则表达式）
• null（空）用到再撸
• undefined（未定义）用到再撸

JavaScript 还有一种内置的 Error（错误）类型。但是，如果我们继续使用上面的分类，事情便容易得多；所以，现在，我们先讨论上面这些类型。

二变量

在 JavaScript 中声明一个新变量的方法是使用关键字 let 、const 和 var  ，作用域需要注意。 初始变量没有对其赋值，那么这个变量的类型就是 undefined，js中是根据值来反推变量类型

let 常量

// myLetVariable 不能用

for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
  // myLetVariable 只能在这里用
}

// myLetVariable 不能用

const 不可变常量--

const Pi = 3.14; // 设置 Pi 的值  
Pi = 1; // 将会抛出一个错误因为你改变了一个常量的值

var 变量 全局可用

// myVarVariable 可用

for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) { 
  // myVarVariable 可用
} 

// myVarVariable 可用

运算符

javaScript的算术操作符包括 +、-、*、/ 和 % 。赋值使用 = 运算符，此外还有一些复合运算符，如 += 和 -=，它们等价于 x = x operator y。

+号比较特殊：

1、数字和字符串相加，按照字符串处理

"3" + 4 + 5; // 345
3 + 4 + "5"; // 75

2、字符和字符相加如下 

"hello" + " world";

比较符号中有==和===区别，>= 和>==同左

123 == "123" // true
1 == true; // true

如果在比较前不需要自动类型转换，应该使用由三个“=（等号）”组成的相等运算符：

1 === true; //false
123 === "123"; // false

三：控制符 if -else while do-while  for-in for-of for 等就不说了 世界通用

四：对象

JavaScript 中的对象与下面这些概念 类似 不是一致

• Python 中的字典（Dictionary）
• Perl 和 Ruby 中的散列/哈希（Hash）
• C/C++ 中的散列表（Hash table）
• Java 中的散列映射表（HashMap）
• PHP 中的关联数组（Associative array）
• oc 中的字段（Dictionary）

下面这俩创建对象例子很重要 用心feel一下！和咱们熟悉的语言左下比较，我是写oc的，这俩例子让我觉得是oc的对象+字典，第二种叫“对象字面量”

var obj = new Object();

和：

var obj = {};

这种抽象概念，通过举例子 大家和自己熟悉的语言做比较，认真感受。  通过例子感受学习的才真切 

var obj = {
    name: "Carrot",
    "for": "Max",//'for' 是保留字之一，使用'_for'代替
    details: {
        color: "orange",
        size: 12
    }
}

对象的属性可以通过链式（chain）表示方法进行访问：

obj.details.color; // orange
obj["details"]["size"]; // 12

下面的例子创建了一个对象原型，Person，和这个原型的实例，You。

function Person(name, age) {
  this.name = name;
  this.age = age;
}

// 定义一个对象
var You = new Person("You", 24); 
// 我们创建了一个新的 Person，名称是 "You" 
// ("You" 是第一个参数, 24 是第二个参数..)

obj['name'] = 'Simon';
var name = obj['name'];
// can use a variable to define a key
var user = prompt('what is your key?')
obj[user] = prompt('what is its value?')

我的感受是和oc中的字典对象取了个并集。其实理解一下js中对象是个结构体就感觉舒服接受了。

方法

递归方法感受一下方法的形式和调用。 

function countChars(elm) {
    if (elm.nodeType == 3) { // TEXT_NODE
 文本节点
        return elm.nodeValue.length;
    }
    var count = 0;
    for (var i = 0, child; child = elm.childNodes[i]; i++) {
        count += countChars(child);
    }
    return count;
}

注意点，elm是个参数，可以传入多个参数，多余的不使用，可以使用不确定参数个数 

function avg(...args) {
  var sum = 0;
  for (let value of args) {
    sum += value;
  }
  return sum / args.length;
}

avg(2, 3, 4, 5); // 3.5

方法里可以嵌套方法

function parentFunc() {
  var a = 1;

  function nestedFunc() {
    var b = 4; // parentFunc 无法访问 b
    return a + b;
  }
  return nestedFunc(); // 5
}

还有一种匿名函数--没啥意思--不写方法名 ，找个变量接一下这个方法

var avg = function() {
    var sum = 0;
    for (var i = 0, j = arguments.length; i < j; i++) {
        sum += arguments[i];
    }
    return sum / arguments.length;
};
avg();

所以会看到如下奇怪的结构，把匿名函数直接调用

var a = 1;
var b = 2;
(function() {
    var b = 3;
    a += b;
})();

a; // 4
b; // 2

自定义对象

自定义对象也是对象。齐活！哈哈哈  具体看下为什么叫自定义对象

在对象里随便加点自己想要的-叫自定义对象。学习的过程我觉得这章节可以忽略，合并到对象里，他们引入这个章节的目的是为了引出几个重要的概念。

1、this  等同于oc里的self

2、prototype 和oc里property一个意思，但是作用不一样

原话是这么说的 

创建对象Person，然后给Person里prototype添加一个新的属性，系统的对象也可以添加，有点像oc里写个子类，或者是catagroy，也有运行时概念。 是不是感觉所有的语言 都是一个鸟行。哈哈哈

Person.prototype 是一个可以被Person的所有实例共享的对象。它是一个名叫原型链（prototype chain）的查询链的一部分：当你试图访问一个 Person 没有定义的属性时，解释器会首先检查这个 Person.prototype 来判断是否存在这样一个属性。所以，任何分配给 Person.prototype 的东西对通过 this 对象构造的实例都是可用的。

这个特性功能十分强大，JavaScript 允许你在程序中的任何时候修改原型（prototype）中的一些东西，也就是说你可以在运行时(runtime)给已存在的对象添加额外的方法：

var s = "Simon";
s.reversed(); // TypeError on line 1: s.reversed is not a function

String.prototype.reversed = function() {
    var r = "";
    for (var i = this.length - 1; i >= 0; i--) {
        r += this[i];
    }
    return r;
}
s.reversed(); // nomiS

闭包

和oc里block是一个东西，oc里看block语法很奇怪，js里看闭包也很奇怪，我读了3遍才感受到闭包的写法一丢丢意思

仔细读读这个例子和结果可以感受到下，但这个例子我觉得不足以表达闭包的精髓，只为了好理解

function makeAdder(a) {
  return function(b) {
    return a + b;
  }
}
var add5 = makeAdder(5);
var add20 = makeAdder(20);
add5(6); // ?
add20(7); // ?

这里发生的事情和前面介绍过的内嵌函数十分相似：一个函数被定义在了另外一个函数的内部，内部函数可以访问外部函数的变量。唯一的不同是，外部函数已经返回了，那么常识告诉我们局部变量“应该”不再存在。但是它们却仍然存在——否则 adder 函数将不能工作。也就是说，这里存在 makeAdder 的局部变量的两个不同的“副本”——一个是 a 等于 5，另一个是 a 等于 20。那些函数的运行结果就如下所示：

x(6); // 返回 11
y(7); // 返回 27