唳天杰
唳天杰

JSLearning

JSLearning

标签（空格分隔）： 前端学习

基础

值类型

  • Undefine
  • Null
  • Boolean
  • Number
  • String

引用类型

  • Object

Object支持动态创建属性

var person = new Object(); 
person.name = "Hello JavaScript"; 
alert(person .name);

检测类型

var s = "Nicholas" ;
alert(typeof s); //string
person = new Object ();
alert(person instanceof Object );//true

RegExp

var expression1 = /[bc]at/i
var expression2 = new ReqExp("[bc]at","i");

正则表达式字符串匹配元字符以及已经转义过的字符需要双重转义

元字符:( [ { \ ^ $ | ) ? * + . ] }需要转义成"\\["等
已转义的字符:\n \ 需要转义成"\\n" "\\\\"

Function

函数本质上一个对象，是Function类型的实例。

//函数声明
function sum (num1,num2) {
    return num1 + num2;
}
//函数表达式
var sum = function(num1, num2) {
    return num1 + num2;　
}
var sum = new Function("num1","num2","return num1 + num2");//不推荐
//这三种都是定义一个函数，但是sum可以改变的，仅仅是一个指针

没有重载的概念

函数声明和函数表达式的区别

解析器在加载数据的时候，会率先读取函数声明，并使其在执行任何代码之前可用；治愈函数表达式，则必须等解析器执行到它所在的代码行，才会被真正正确的解释执行。

alert(sum(10,10));
function sum (num1,num2) {
    return num1 + num2;
}
//以上代码ok
alert(sum(10,10));
var sum = function(num1, num2) {
    return num1 + num2;　
}
//以上代码error

函数可以当参数，也可以当返回值

函数的内部属性

*arguments(传入函数的所有参数)
*arguments.callee(正在被执行的函数对象)
*arguments.callee.caller(当前函数的调用方)
*this（执行的环境对象，网页的全局域中调用的时候,this就是window,如果作为一个对象的属性调用，比如o.sum(10,10),this就是o这个对象）

函数属性和方法

*length 参数的数量
*prototype
*call,apply 设定函数的作用域，即this的值
*bind 绑定函数的作用域，即this的值

基本的包装类型

特殊的引用类型
*Boolean
*Number
*String

面向对象基础

对象是无序属性的集合，其属性可以包含基本值、对象或者函数。

//对象定义
var person = {
    name:"Nicholas",
    age:29,
    job:"Software Engineer",
    sayName:function(){
        alert(this.name);
    }
}

数据属性

  1. Configurable:是否可以通过delete删除属性
  2. Enumerable:是否可以通过for-in循环返回属性
  3. Writable:是否可写
  4. Value：属性的数据值

对象直接定义和通过defineProperty定义属性的时候以上的各个值默认值不一样，前者都是true,后者都是false,但value都是undefine。

访问器属性

  1. Configurable
  2. Enumerable
  3. Get 读取属性时调用的函数
  4. Set 写入时调用的函数

对象直接定义和通过defineProperty定义属性的时候以上的各个值默认值不一样，前者都是true,后者都是false,但get & set 都是undefine。

var book = {
    _year:2004,
    edition:1
}
Object.defineProperty(book,"year",{
    get:function(){
        return this._year
    }
    set:function(newValue) {
        
        if (newValue > 2004) {
            
            this.year = newValue;
            this.edition = newValue - 2004; 
        }
    }
});

book.year = 2005;
alert(bool.edition)

读取属性的特性

Object.getOwnPropertyDescriptor

创建对象

工厂模式

function createPerson(name,age,job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function() {
        alert(this.name);
    }
    return o;
}

构造函数模式

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function() {
        alert(this.name);
    }
}
var person1 = new Person("Greg",27,"Doctor");
//person1会有一个construtor(构造函数)属性 指向Person

使用new加构造函数创建实例会经历以下4个步骤

  1. 创建一个新的对象
  2. 将构造函数的作用域赋给对象(因此this指向了这个新对象)
  3. 执行构造函数中的代码（为这个对象添加属性）
  4. 返回新的对象

对象类型检测

alert(person1 instanceof Person);//true;
alert(person1 instanceof Object);//true

构造函数的问题

属性时函数对象的对象，会重复创建。

原型模式

每个函数都有一个prototype属性，是一个指针，指向一个对象，作用是让实例共享属性和方法。

原型对象的理解

function Person() {
}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function() {
    alert(this.name);
}

var person1 = new Person();
person1.sayName();//访问原型对象的
  • Person(函数对象)
  • Peron.prototype(原型对象)
  • person1(实例)

函数对象通过prototype属性访问原型对象，原型对象可以通过constructor对象访问函数对象，实例对象可以通过[[Prototype]]访问原型对象。
每当读取实例的某个属性的时候，都会执行一个搜索，首先搜索实例本身，然后沿着原型链搜索。

原型链：通过[Prototype]]属性连接起来，末端是Object.prototype

调用实例函数的时候，即使这个函数是原型对象定义,函数中的this依然指向当前实例
对象中新增一个和原型对象重名属性时，不会重写原型的值，而是新增一个属性，并屏蔽原型对象的属性
hasOwnProperty()判断某个属性是否是实例属性。
!object.hasOwnProperty(name) && (name in object)判断name是object原型对象的方法

原型的动态性

实例创建后修改原型，也能从实例中反映出来。

组合使用构造函数模式和原型模式

最常用的创建对象的方式

function Person(name,age,job) {
    this.name = name;
    this.age = age;
    this.jog = job;
    this.friends = ["shelby","court"];
}
Person.prototype.sayName = function() {
    alert(this.name);
}
var person1 = new Person("Nicholas",29,"Doctor");
//实例属性在构造函数中定义，所有实例共享原型对象的属性，这个是默认模式

动态原型模式

function Person(name,age,job) {
    this.name = name;
    this.age = age;
    this.jog = job;
    if (typeof this.sayName != "function") {
        Person.prototype.sayName = function() {
            alert(this.name);
        }
    }
}

继承

原型链继承

function SuperType() {
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}

function SubType() {
    this.subProperty = false;
}

//继承了SuperType
SubType.prototype = new SuperType();
//修复constructor
SubType.prototype.constructor = SubType;
SubType.prototype.getSubVale = function() {
    return this.subproperty;
}
var instance = new SubType();
alert(instance.getSuperValue());//true

以上代码最终形成这样的关系

SubType实例 -> SuperType实例(SubType.prototype) -> SuperType.prototype(Object实例) -> Object.prototype
SubType继承SuperType,SuperTyper继承Object

所有类型默认都继承Object类型，原因是默认原型都是Object的实例，指向了Object.prototype。

确定原型和实例的关系

alert(instance instanceof Object);//true
alert(instance instanceof SuperType);//true
alert(instance instanceof SubType);//true

给原型添加新方法，一定要放在替换原型语句之后

单纯的原型链问题：父类如果定义属性，被子类继承的时候，会被各个子类的实例共享，创建子类类型的时候，不能像父类传递属性。

构造函数继承

function SupetType(name) {
    this.name = name;
}

function SubType() {
    //继承了SuperType,同时还传递了参数
    SuperType.call(this,"Nicholas");
    
    //实例属性
    this.age = 29;
}
var instance = new SubType();
alert(instance.name);//Nicholas;
alert(instance.age);//29

借用构造函数的问题:函数属性在构造函数内部定义，无复用，超类型原型中定义的方法，对子类不可见。

组合模式

最常用的继承方式

function SuperType(name) {
    this.name = name;
    this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName = function() {
    alert(this.name);
};

function SubType(name,age) {
    //继承属性
    SuperType.call(this,name);
    //子类属性
    this.age = age;
}

//继承方法
SubType.prototype = new SuperType();
//修正constructor
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function() {
    alert(this.age);
};

var instance1 = new SubType("Nicholas",29);
instance1.colors.push("black");
alert(instance1.colors);//"red,blue,green,black"
instance1.sayName();///Nicholas
instance1.sayAge();//29

var instance2 = new SubType("Greg",27);
alert(instance2.colors);//"red,bule,green"
instance2.sayName();//Greg
instance2.sayAge();//27

浅复制

var person = {
    name:"Nicholas",
    friends:["Shelby","Court","Van"]
}

var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");

alert(person.friends);//"Shelby,Court,Van,Rob,Barbie"
//覆盖同名属性
var haAnotherPerson = Object.create(person,{
    name:{
        value:"Greg"
    }});
alert(anotherPerson.name);//Greg

//这个函数的作用和Object.create传入一个参数时行为相同
function object(o) {
    function F(){}
    F.prototype = o;
    return new F();
}

寄生组合式继承

最理想的继承范式

function SuperType(name) {
    this.name = name;
    this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName = function() {
    alert(this.name);
};

function SubType(name,age) {
    //继承属性
    SuperType.call(this,name);
    //子类属性
    this.age = age;
}

function object(o) {
    function F(){}
    F.prototype = o;
    return new F();
}

function inheritPrototype(subType,superType) {
    var prototype = object(superType.prototype);
    prototype.constructor = subType;
    subType.prototype = prototype;
}

inheritPrototype(SubType,SuperType);
SubType.prototype.sayAge = function() {
    alert(this.age);
};

var instance1 = new SubType("Nicholas",29);
instance1.colors.push("black");
alert(instance1.colors);//"red,blue,green,black"
instance1.sayName();///Nicholas
instance1.sayAge();//29

var instance2 = new SubType("Greg",27);
alert(instance2.colors);//"red,bule,green"
instance2.sayName();//Greg
instance2.sayAge();//27

函数表达式

//函数声明提升，调用可以放在声明前
sayHi();
function sayHi() {
    alert("Hi!");
}

//函数表达式，错误，函数还不存在
sayHi();
var sayHi = function() {
    alert("Hi!");
}

递归

function factorial(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * arguments.callee(num-1);
    }
}

//命名函数表达式
var factorial = (function f(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * f(num-1);
    }
})

闭包

类似于block,定义的时候可以引用外部变量，并持有。

function crateComparisonFunction(propertyName) {
    
    return function(object1,object2) {
        //引用了propertyName
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        
        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {u
            retrn 0;
        }
    };
}

闭包和变量

function createFunctions() {
    var result = new Array();
    
    for (var i = 0;i < 10; i++) {
        result[i] = function() {
            return i;
        }
    }
    
    //result数组中 每个函数变量i都是10 不是copy 只是引用
    return result;
}

function createFunctions() {
    
    var result = new Array();
    
    for (var i = 0;i < 10;i++) {
        result[i] = function(num){
            return function() {
                return num;
            }
        }(i);
    }
    
    //result数组中 每个函数的变量num就是从0到9
    return result;
}

关于this

var name = "The Window";

var object = {
    name:"My Object".
    getNameFunc:function() {
        return function() {
            return this.name;
        }
    }
}
alert(object.getNameFunc()());//"The Window";
//这个调用和以上相同 所以this=window.
var f = object.getNameFunc();
alert(f();)

var name = "The Window";

var object = {
    name:"My Object".
    getNameFunc:function() {
        var that = this;
        return function() {
            return that.name;
        }
    }
}
alert(object.getNameFunc()());//"My Object";

内存泄露

function assignHandler() {
    var element = document.getElementById("someElement");
    //循环引用 
    element.onclick = function() {
        alert(element.id);
    }
}

//破除循环引用
function assignHandler() {
    var element = document.getElementById("someElement");
    var id = element.id;
    //循环引用 
    element.onclick = function() {
        alert(id);
    }
    //局部变量设置为null,闭包也不会引用element，就不会循环引用了。
    element = null;
}

闭包会引用包含函数的局部变量，即使没有直接引用局部变量，进而闭包会持有局部变量指向的对象，要破除这种持有，可以将局部变量设置为null在包含函数结束前。

模仿块级作用域

(function() {
    //这里是块级作用域
})();

私有变量

funciton MyOject() {
    //私有变量和私有函数
    var privateVariable = 10;
    
    function privateFunction() {
        return false;
    }
    
    //特权方法
    this.publicMethod = function() {
        privateVariable++;
        return privateFunction();
    }
}
var object = new MyObject();
alert(object.publicMethod);

静态私有变量

(function() {
    
    //私有变量和私有函数
    var privateVariable = 10;
    
    function privateFunction() {
        return false;
    }
    
    //构造函数 未经声明的变量，会创建一个全局变量。
    MyObject = function() {
    
    };
    //公有/特权方法
    MyOject.prototype.publicMethod = function() {
        privateVariable++;
        return privateFunction();
    };
})

模块模式

var singleton = function() {
    //私有变量和函数
    var privateVariable = 10;
    
    function privateFunction() {
        return false;
    }
    
    //公有方法和属性
    return {
        publicProperty:true,
        publicMethod:function() {
            privateVariable++;
            return privateFunction();
        }
    }
}();

增强的模块模式

var singleton = function() {
    //私有变量和函数
    var privateVariable = 10;
    
    function privateFunction() {
        return false;
    }
    //创建对象
    var object = new CustomType();
    
    //添加公有方法和属性
    object.publicProperty = true;
    object.publicMethod = function() {
            privateVariable++;
            return privateFunction();
    };

    return object;
}();

你可能感兴趣的:(JSLearning)

  • JS学习记录 _Henry_
    JSLearning一、请做好准备基本操作document.write("hello");document.getElementById("p1").style.color="white";引用js文件执行顺序放在部分最常用的方式是在页面中head部分放置元素，浏览器解析head部分就会执行这个代码，然后才解析页面的其余部分。放在部分JavaScript代码在网页读取到该语句的时候就会执行。分隔符
  • NodeJS 简介与命令介绍 SerendipityA
    Node.jsLearning1.命令行1.环境变量=>path当我们在命令行窗口打开一个文件，或调用一个程序时，系统回收现在当前目录下寻找文件程序，如果找到了则直接打开，如果没有找到，会依次在环境变量Path中寻找，直到找到为止，如果没找到就报错。相似：作用域vara=100;functionfn(){vara=200;functionfn2(){vara=300;console.log(a);
  • JSLearning 唳天杰
    JSLearning标签（空格分隔）：前端学习基础值类型UndefineNullBooleanNumberString引用类型ObjectObject支持动态创建属性varperson=newObject();person.name="HelloJavaScript";alert(person.name);检测类型vars="Nicholas";alert(typeofs);//stringper
  • js实现懒加载 csdnluolei 【JavaScript】
    当一个页面有很多数据的时候，需要全部加载后，才显示，网速不好时需要等很久。当用懒加载后，就只加载可视区的数据，反应更快，效果更好。jsLearning-懒加载#box{width:80%;margin:0auto;}#boxli{list-style:none;width:180px;height:250px;border:1pxsolidblack;float:left;margin-left:
  • Java常用排序算法/程序员必须掌握的8大排序算法 cugfy java
    分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（基数排序） 所需辅助空间最多：归并排序 所需辅助空间最少：堆排序 平均速度最快：快速排序 不稳定：快速排序，希尔排序，堆排序。 先来看看8种排序之间的关系：   1.直接插入排序 （1
  • 【Spark102】Spark存储模块BlockManager剖析 bit1129 manager
    Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
  • linux 查看端口被占用情况详解 daizj linux端口占用netstatlsof
    经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序   1、lsof -i:port port为端口号   [root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 COMMAND   PID USER   FD   TY
  • Hosts文件使用 周凡杨 hostslocahost
         一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
  • java excel工具 g21121 Java excel
    直接上代码，一看就懂，利用的是jxl： import java.io.File; import java.io.IOException; import jxl.Cell; import jxl.Sheet; import jxl.Workbook; import jxl.read.biff.BiffException; import jxl.write.Label; import
  • web报表工具finereport常用函数的用法总结（数组函数） 老A不折腾 finereportweb报表函数总结
    ADD2ARRAY ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。 示例： ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. ADDARRAY([3,4, 1, 5, 7], "测试&q
  • 游戏服务器网络带宽负载计算 墙头上一根草 服务器
    家庭所安装的4M，8M宽带。其中M是指，Mbits/S 其中要提前说明的是： 8bits = 1Byte 即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 8Mbits/s后面的S是秒。8Mbits/s意思是 每秒8M位，即每秒1M字节。 我是在计算我们网络流量时想到的
  • 我的spring学习笔记2-IoC（反向控制 依赖注入） aijuans Spring 3 系列
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
  • 高性能mysql 之 选择存储引擎(一) annan211 mysqlInnoDBMySQL引擎存储引擎
    1 没有特殊情况，应尽可能使用InnoDB存储引擎。   原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她   被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃   恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
  • UDP网络编程 百合不是茶 UDP编程局域网组播
      UDP是基于无连接的,不可靠的传输   与TCP/IP相反       UDP实现私聊,发送方式客户端,接受方式服务器 package netUDP_sc; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.Ine
  • JQuery对象的val()方法执行结果分析 bijian1013 JavaScriptjsjquery
            JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。        
  • http请求测试实例（采用json-lib解析） bijian1013 jsonhttp
            由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 package com; import java.util.HashMap; import java.util.Map; import
  • 【RPC框架Hessian四】Hessian与Spring集成 bit1129 hessian
    在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。   定义模型、接口和服务器端代码 |---Model    &nb
  • 【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析 bit1129 Mahout
    1.Mahout环境搭建  1.下载Mahout http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz    2.解压Mahout  3. 配置环境变量 vim /etc/profile export HADOOP_HOME=/home
  • nginx负载tomcat遇非80时的转发问题 ronin47
    　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port        详细如下： 　　 该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的： ? 1 2 3 4 5
  • java-17-在一个字符串中找到第一个只出现一次的字符 bylijinnan java
    public class FirstShowOnlyOnceElement { /**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b * 1.int[] count:count[i]表示i对应字符出现的次数 * 2.将26个英文字母映射：a-z <--> 0-25 * 3.假设全部字母都是小写 */ pu
  • mongoDB 复制集 开窍的石头 mongodb
    mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题             mo
  • [宇宙与天文]宇宙时代的经济学 comsci 经济
        宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。      在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源      以目前地球上国家的经济发展水平来讲，
  • Git忽略文件 Cwind git
         有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。 ==== ==== ==== 一些牢骚
  • MySQL连接数据库的必须配置 dashuaifu mysql连接数据库配置
    MySQL连接数据库的必须配置   1.driverClass：com.mysql.jdbc.Driver   2.jdbcUrl：jdbc:mysql://localhost:3306/dbname   3.user：username   4.password：password   其中1是驱动名；2是url，这里的‘dbna
  • 一生要养成的60个习惯 dcj3sjt126com 习惯
    一生要养成的60个习惯 第1篇 让你更受大家欢迎的习惯 1 守时，不准时赴约,让别人等,会失去很多机会。 如何做到： ①该起床时就起床， ②养成任何事情都提前15分钟的习惯。 ③带本可以随时阅读的书，如果早了就拿出来读读。 ④有条理，生活没条理最容易耽误时间。 ⑤提前计划：将重要和不重要的事情岔开。 ⑥今天就准备好明天要穿的衣服。 ⑦按时睡觉，这会让按时起床更容易。 2 注重
  • [介绍]Yii 是什么 dcj3sjt126com PHPyii2
    Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作 易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。 Yii 最适合做什么？ Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
  • Linux SSH常用总结 eksliang linux sshSSHD
    转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机   格式： ssh name@remoteserver 例如： ssh [email protected]   二、连接到远程主机指定的端口   格式： ssh name@remoteserver -p 22 例如： ssh i
  • 快速上传头像到服务端工具类FaceUtil gundumw100 android
    快速迭代用 import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOExceptio
  • jQuery入门之怎么使用 ini JavaScripthtmljqueryWebcss
    jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？   首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
  • 带filter的hbase查询优化 kane_xie 查询优化hbaseRandomRowFilter
    问题描述 hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。   问题原因 直接原因是： hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
  • java设计模式-单例模式 men4661273 java单例枚举反射IOC
             单例模式1，饿汉模式 //饿汉式单例类.在类初始化时，已经自行实例化 public class Singleton1 { //私有的默认构造函数 private Singleton1() {} //已经自行实例化 private static final Singleton1 singl
  • mongodb 查询某一天所有信息的3种方法，根据日期查询 qiaolevip 每天进步一点点学习永无止境mongodb纵观千象
    // mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。 // 第一种方式： coll.aggregate([ {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}}, {$match:{sendDate: '2015-
  • 二维数组转换成JSON tangqi609567707 java二维数组json
    原文出处：http://blog.csdn.net/springsen/article/details/7833596 public class Demo {     public static void main(String[] args) {        String[][] blogL
  • erlang supervisor wudixiaotie erlang
    定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他