a java rnvironme_RN精进笔记（一）入门篇

node常用命令

$ node /user/helloworld.js

node REPL(Read-eval-print loop)模式

创建HTTP服务器(前提是你已经安装好node)

var http = require('http');

http.createServer(function(request, response) {

response.writeHead(200, {'Content-Type': 'text/html'});

response.write('

Node.js

');

response.end('

Hello world

');

}).listen(3000);

console.log("HTPP server is listening at port 3000");

#运行这段代码，然后在浏览器中访问：http://127.0.0.1:3000

supervisor解决调试问题

$ npm info supervisor

$ npm install supervisor

$ supervisor helloworld.js

异步 I/O与事件式编程

1.阻塞与线程

2.同步I/O或阻塞式I/O

3.异步I/O或非阻塞式I/O

4.事件循环

#异步读取文件，异步I/O通过回调函数实现

var fs = require('fs');

fs.readFile('/Users/schiller/Desktop/file.txt', 'utf-8', function(error, data) {

if(error) {

console.log(error);

}else {

console.log(data);

}

});

console.log('end');

#我们会发现先打印end 再打印file.txt的content

#同步读取文件，阻塞之后再读取

var fs = require('fs');

var data = fs.readFileSync('file.txt', 'utf-8');

console.log(data);

console.log('end.');

express框架研究

$ npm install -g express

$ /Users/gaolong/.nvm/versions/node/v5.7.0/lib

$ 仔细阅读Readme.md文档

$ npm install -g express-generator@4

$ express fisrtExpressDemo

$ cd firstExpressDemo && npm install //install

dependencies

$ npm start //启动应用

$ 浏览器输入 'http://localhost:3000'

$ DEBUG=firstExpressDemo:* npm start //run the app

#examples

$ git clone git://github.com/expressjs/express.git --depth 1

$ cd express

$ npm install

$ node examples/content-negotiation

react-native学习计划

1.持续学习ES6，了解ES5

2.RN官方文档

3.node.js了解js服务器编程，了解RN调试

JavaScript高级特性

1.作用域

var v1 = 'v1';

var f1 = function() {

console.log(v1); //v1

}

var v2 = "global";

var f2 =function() {

console.log(v2);//undefined,javascript会先搜索f2作用域

v2 = "scope";

}

var f = function() {

var scope = 'f0';

(function() {

var scope = 'f1';

(function() {

console.log(scope); //f1 ,这里取得的是其父作用域的值

})(); //函数作用域的嵌套关系是定义时决定的，不是调用时决定的

})();

};

f();

#全局作用域与全局对象

global对象、window对象、DOM对象

2.闭包

var generateClosure = function() {

var count = 0;

var get = function() {

count++;

return count;

};

return get;

};

var counter = generateClosure();

console.log(counter()); //1

console.log(counter()); //2

console.log(counter()); //3

#当一个函数返回它内部定义的一个函数时，就产生一个闭包，闭包不但包括被返回的函数，还包括这个函数的定义环境。上例中couter和generateClosure()的局部变量就是一个闭包。

#闭包用作：嵌套的回调函数、实现私有成员

3.对象

var foo = {};

foo.pro_1 = 'bar';

foo.prop_2 = false;

foo.prop_3 = function() {

return 'Hello world';

};

foo['pro_4'] = '关联数组';

console.log(foo.prop_3);

console.log(foo.pro_4);

console.log(foo['pro_4']);

#使用关联数组创建、访问对象成员、使用对象初始化器创建对象

#构造函数创建对象

function User(name, uri) {

this.name = name;

this.uri = uri;

this.display = function() {

console.log(this.name);

console.log(this);

}

}

var someUser = new User('gaolong', 'http://gaolong.com');

console.log(someUser.name);

someUser.display();

#this指针是引用所属的对象

#call、aplly的功能是允许一个对象去调用另一个对象的成员函数！！！

#call 和apply的功能是一致的，区别在于call以参数表来接收被调用函数的参数，而apply以数组来接收被调用函数的参数。

#bind

var someGirl = {

name: 'beauty',

func: function() {

console.log(this.name);

}

};

var foo = {

name: 'ugly',

};

foo.func = someGirl.func;

foo.func(); //ugly

foo.func1 = someGirl.func.bind(someGirl);

foo.func1(); //beauty

func = someGirl.func.bind(foo);

func();//ugly

func2 = func;

func2(); //ugly

#原型

1.构造函数内定义的属性继承方式与原型不同,子对象需要显式调用父对象才能继承构 造函数内定义的属性。

2.构造函数内定义的任何属性,包括函数在内都会被重复创建,同一个构造函数产生的 两个对象不共享实例。

3.构造函数内定义的函数有运行时闭包的开销,因为构造函数内的局部变量对其中定义 的函数来说也是可见的。

function FooMe() {

var innerVar = 'hello tomorrow';

this.prop1 = 'gaolongxiaoxiao';

this.func1 = function () {

innerVar = '';

}

}

FooMe.prototype.prop2 = 'Carbo';

FooMe.prototype.func2 = function () {

console.log(this.prop2);

}

var foo1 = new FooMe();

var foo2 = new FooMe();

console.log(foo1.func1 == foo2.func1); //false

console.log(foo1.func2 == foo2.func2); //true

//除非必须用构造函数闭包，否则尽量用原型定义成员函数，因为这样可以减少开销

//尽量在构造函数内定义一般成员，尤其是对象数组，因为用原型定义的成员是多个实例共享的。

#原型链

特殊对象：Object 、 Function

Object.prototype是所有对象的祖先，Function.prototype是所有函数的原型，包括构造函数。

用户创建的对象：new 显式构造的对象

构造函数对象：普通的构造函数,即通过 new 调用生成普通对象的函数。

原型对象：特指构造函数 prototype 属性指向的对象

这三类对象中每一类都有一个 __proto__ 属 性,它指向该对象的原型,从任何对象沿着它开始遍历都可以追溯到 Object.prototype。

function FooYou() {

}

Object.prototype.name = 'My Object';

FooYou.prototype.name = 'Bar';

var obj = new Object();

var foo = new FooYou();

console.log(obj.name); //'My Object'

console.log(foo.name); // 'Bar'

console.log(foo.__proto__.name); // 'Bar'

console.log(foo.__proto__.__proto__.name); // 'My Object'

console.log(foo.__proto__.constructor.prototype.name); // 'Bar'

foo: __proto__

FooYou:__proto__.prototype

Foo.prototype:__proto__.constructor

Function: __proto__ & prototype

Function.prototype: __proto__ & constructor

obj: __proto__

Object: __proto__.protype

Object.prototype: __proto__ & constructor

__proto__是实例为获取其类的原型而设置的一个属性！！！

在 JavaScript 中,继承是依靠一套叫做原型链(prototype chain)的机制实现的。属性 继承的本质就是一个对象可以访问到它的原型链上任何一个原型对象的属性。例如上例的foo 对象,它拥有 foo. __proto__ 和 foo. __proto__.__proto__ 所有属性的浅拷 贝(只复制基本数据类型,不复制对象)。所以可以直接访问foo.constructor(来自foo. __proto__,即Foo.prototype),foo.toString(来自foo. __proto__.__proto__, 即Object.prototype)。

console.log(foo.__proto__); //FooYou { name: 'Bar'}

console.log(FooYou.prototype); //FooYou{ name: 'Bar'}

console.log(FooYou.prototype.__proto__); //{name: 'My Object'}

console.log(FooYou.prototype.__proto__.constructor); //[Function : Ojbect]

console.log(FooYou.prototype.__proto__.prototype); // null

console.log(FooYou.prototype.__proto__.__proto__); // undefined

console.log(foo.prototype); //undefined

#对象的复制

浅拷贝VS深拷贝

浅拷贝：共享对象属性

Object.prototype.clone = function() {

var newObj = {};

for (var i in this) {

newObj[i] = this[i];

}

return newObj;

}

var obj = {

name: 'gaolongxiaohua',

likes: ['node', 'OC']

};

var newObj = obj.clone();

obj.likes.push('python');

console.log(obj.likes); //[ 'node', 'OC', 'python' ]

console.log(newObj.likes); //[ 'node', 'OC', 'python' ]

深拷贝：递归实现、对象中可能有对象

Object.prototype.deepClone = function() {

var newOjb = {};

for (var i in this) {

if (typeof(this[i]) == 'object' || typeof(this[i]) == 'function') {

newObj[i] = this[i].deepClone();

}else {

newObj[i] = this[i];

}

}

return newObj;

}

Array.prototype.deepClone = function() {

var newArray = [];

for (var i=0; i < this.length; i++) {

if (typeof(this[i]) == 'object' || typeof(this[i]) == 'function') {

newArray[i] = this[i].deepClone();

}else {

newArray[i] = this[i];

}

}

return newArray;

}

Function.prototype.deepClone = function() {

var that = this;

var newFunc = function() {

return that.apply(this, arguments);

};

for (var i in this) {

newFunc[i] = this[i];

}

return newFunc;

};

var obj33 = {

name: 'xiaohua',

likes: ['hua', 'shit'],

display: function() {

console.log('chishi');

}

};

var newObj33 = obj.deepClone();

newObj33.likes.push('shishishihis');

console.log(obj33.likes); //['hua', 'shit']

console.log(newObj33.likes);// ['hua', 'shit','shishishihis']

#注意:这种实现方式对于循环引用无法生效，甚至出现循环递归

原型链

[图片上传失败...(image-39b111-1527822985817)]

over

over