单例模式 - coderlwz

本邮件内容由第三方提供，如果您不想继续收到该邮件，可 点此退订 。

单例模式 - coderlwz  阅读原文»

*懒汉式：(多线程高并发访问时要考虑同步问题)
>代码，以用户实体为例(User)
publiuc class User{

/*1. 用户实体,静态全局依赖,类加载时即初始化为空指针，没有内存地址，但还
*是可以引用
*/
private static User instance=null;

//2. 私有的构造函数，外部不能有以new关键字在堆内存中新创建的对象
private User(){}

//懒汉式，懒加载实例化的对象
public static synchronized User getInstace(){

//如果实例化对象为空指针
if(!instancre){
//实例化当前对象
instance=new User();
return instance;
}else{
//否则返回当前实例化的对象
return instance;
}
}
}
*饿汉式：
>代码,以用户实体为例(User)：
public class User{

//类加载即初始化user对象，饿汉式，饥饿加载,
private static User instance=new User();

//供外部访问接口,得到供外部访问的实例化对象
public static User getInstance(){
return instance;
}

//私有构造函数，模拟数据库
private User(){
}
}
注：单例模式，只应许有一个类的实例，所以构造函数是私有的。
*懒汉是不是在类加载时初始化类的实例化对象，不能保证对象的唯一性，所以在多线程的情况下尽管有
实例对象空值的判断，也会产生线程安全的问题，因为多线程是按照时间片来运行线程的，破坏类代码
的垂直执行的顺序，因此加上同步关键字synchronized,是代码块同步，线程安全。
*饿汉式因为是在类加载的时候实例化静态类对象，因此无论何时都只有一个静态的全局依赖类对象，
不会有线程的安全问题。

本文链接：单例模式，转载请注明。

NodeJS入门（四）―― path对象 - vajoy  阅读原文»

很快Node就会迎来4.0的时代，届时将并入现有的iojs，所以先前写过的iojs入门系列直接更名为NodeJS入门。

本篇开始将逐个介绍Node的各主要模块，依循API文档走一遍，但会给出比API文档更详尽的示例。

所有的示例都可以在我的Github上下载到（暂时传不了，这段时间VPN统统失效，你懂的。。。）。

API系列的开篇打算以 path 对象开始，因为之前在写一些gulp插件，发现path的使用频率实在太高了，掌握之有助于我们处理好一些文件或文件夹的路径。

path.normalize(p)

标准化路径字符串，处理冗余的“..”、“.”、“/”字符：

var path = require('path');

var url1 = path.normalize('a/b/c/../user/vajoy/bin');
var url2 = path.normalize('a/b/c///../user/vajoy/bin/');
var url3 = path.normalize('a/b/c/../../user/vajoy/bin');
var url4 = path.normalize('a/b/c/.././///../user/vajoy/bin/..');
var url5 = path.normalize('a/b/c/../../user/vajoy/bin/../../');
var url6 = path.normalize('a/../../user/vajoy/bin/../../');
var url7 = path.normalize('a/../../user/vajoy/bin/../../../../');
var url8 = path.normalize('./a/.././user/vajoy/bin/./');

console.log('url1:',url1); // a\b\user\vajoy\bin
console.log('url2:',url2); // a\b\user\vajoy\bin\
console.log('url3:',url3); // a\user\vajoy\bin
console.log('url4:',url4); // a\user\vajoy
console.log('url5:',url5); // a\user\
console.log('url6:',url6); // ..\user\
console.log('url7:',url7); // ..\..\
console.log('url8:',url8); // user\vajoy\bin\

path.join([path1], [path2], [...])

将多个路径结合在一起，并转换为标准化的路径：

var path = require('path');

var url1 = path.join('////./a', 'b////c', 'user/', 'vajoy', '..');
var url2 = path.join('a', '../../', 'user/', 'vajoy', '..');
var url3 = path.join('a', '../../', {}, 'vajoy', '..');

console.log('url1:',url1); // \a\b\c\user
console.log('url2:',url2); // ..\user
console.log('url3:',url3); // 存在非路径字符串，故抛出异常

path.resolve([from ...], to)

从源地址 from 到目的地址 to 的绝对路径。

可以理解为 cd XXX 的形式，如在D盘上执行 path.resolve('a', 'D:/b', '../c', 'v.txt')，得到的绝对路径“D:/v.txt”，相当于执行如下指令后所处的路径：

cd a
D:
cd b //同上一行对应 'D:/b'
cd ../c
cd v.txt

要注意的是，如果某个 from 或 to 参数是绝对路径（比如 'E:/abc'，或是以“/”开头的路径），则将忽略之前的 from 参数。

示例：

var path = require('path');

var url1 = path.resolve('.', 'testFiles/..', 'trdLayer');
var url2 = path.resolve('..', 'testFiles', 'a.txt');
var url3 = path.resolve('D:/vajoy', 'abc', 'D:/a');
var url4 = path.resolve('abc', 'vajoy', 'ok.gif');
var url5 = path.resolve('abc', '/vajoy', '..', 'a/../subfile'); //'abc'参数将被忽略，源路径改从'E:/vajoy'开始

console.log('url1:',url1); // E:\github\nodeAPI\path\trdLayer
console.log('url2:',url2); // E:\github\nodeAPI\testFiles\a.txt
console.log('url3:',url3); // D:\a
console.log('url4:',url4); // E:\github\nodeAPI\path\abc\vajoy\ok.gif
console.log('url5:',url5); // E:\subfile

path.isAbsolute(path)

判断 path 是否绝对路径。这块可以理解为，path 是否真的是一个绝对路径（比如 'E:/abc'），或者是以“/”开头的路径，二者都会返回true：

var path = require('path');

var url1 = path.isAbsolute('../testFiles/secLayer');
var url2 = path.isAbsolute('./join.js');
var url3 = path.isAbsolute('temp');
var url4 = path.isAbsolute('/temp/../..');
var url5 = path.isAbsolute('E:/github/nodeAPI/abc/efg');
var url6 = path.isAbsolute('///temp123');

console.log('url1:',url1); // false
console.log('url2:',url2); // false
console.log('url3:',url3); // false
console.log('url4:',url4); // true
console.log('url5:',url5); // true
console.log('url6:',url6); // true

path.relative(from, to)

获取从 from 到 to 的相对路径，可以看作 path.resolve 的相反实现：

path.resolve(from, path.relative(from, to)) == path.resolve(to)

示例：

var path = require('path');

var url1 = path.relative('C:\\vajoy\\test\\aaa', 'C:\\vajoy\\impl\\bbb');
var url2 = path.relative('C:/vajoy/test/aaa', 'C:/vajoy/bbb');
var url3 = path.relative('C:/vajoy/test/aaa', 'D:/vajoy/bbb');

console.log('url1:',url1); //..\..\impl\bbb
console.log('url2:',url2); //url2: ..\..\bbb
console.log('url3:',url3);