本文目录一览：
- 1、JAVASCRIPT如何获取远程页面内容
- 2、如何实现 JS 远程控制服务器开关机？
- 3、js 远程调用 怎么实现
- 4、JavaScript怎么连接远程服务器，只要能建立通信就行。不需要任何功能？
- 5、远程调用js
JAVASCRIPT如何获取远程页面内容
JS AJAX技术获取网页源代码是不行的...
要用其他方法...
例如,我用PHP的套接字模拟HTTP协议的方式编写一个获取源代码的PHP程序.
再用JS AJAX调用这个PHP程序.. 就能实现跨域了..
当然,你如果会JAVA,直接写个JAVA Applet也行...利用 URLConnection类,获取源代码轻而易举...
如何实现 JS 远程控制服务器开关机？
首先，你的服务器JS是控制不了的，必须用C,C++之类的后台语言控制，至于JS就是发个信号给你的服务器，让你的服务器后台语言控制这个服务器的开和关
js 远程调用 怎么实现
RMI: Remote Method Invoke 远程方法调用
用js调用java，java实现远程调用。
jsonRPC 机制调用
ajax 调用
JavaScript怎么连接远程服务器，只要能建立通信就行。不需要任何功能？
你说的连接是指什么？访问也是连接啊，你用js从远程服务器下载一个文件，这也算连接啊。
如果你是指登录远程服务器的话，这个需要远程服务器首先提供了登录接口，否则是登录不了的
远程调用js
JsLoader，动态加载远程js代码
/**
* Construct a new JSLoaderEnvironment instance
* @class JSLoaderEnvironment is the class designed to be a
* representation of a unix-like shell environment.
* The purpose of this is to allow the infrastructure to abstract
* away any library file location knowledge for rapid and enterprise
* adoption and deployment
*/
function JSLoaderEnvironment(){
// Default
this.prefix="/assets/";
// Auto-discover location
var _remote=false;
var s=0;
var _script_tags=document.getElementsByTagName("script");
var endsWith=function(str, substr){
return (str str.indexOf(substr) == (str.length-substr.length));
};
for(s=0;s_script_tags.length;++s){
var src=_script_tags[s].src;
var src_orig=src;
if(src){
if(src.indexOf("://")-1)
{
src=src.substring(src.indexOf("://")+3);
src=src.substring(src.indexOf("/"));
}
if(endsWith(src,"jsloader.js") || endsWith(src,"jsloader-debug.js")) {
// If the domain is remote, assume we're running in hosted mode
_remote=(src_orig.indexOf(document.domain)==-1);
if(_remote) src=src_orig;
this.prefix=src.substring(0, src.lastIndexOf("/")+1);
}
}
}
/**
* @private
*/
this.suffix=".js";
/**
* @private
* Make the Path of a module to meta/proj/release
*/
this.makeJSLoaderPath=function(m,p,r,suff){
// if just a url is specified, use it
if(!p !r) return this.stripExternalRef(m);
// build the m/p/r path
return this.prefix+m+"/"+p+"/incr/versions/"+r+ ((suff)?this.suffix:"");
}
/**
* The generate the path prefix for a MPR linked into the JSLoader Environmentiables
* @param m meta
* @param p project
* @param r release
*/
this.makePath=function(m,p,r){
// if just a url is specified, use it
if(!p !r) return this.stripExternalRef(m);
// build the m/p/r path
return this.prefix + m +"/" + p + "/" + r + "/";
}
/**
* @private
*/
this.env=new Object();
/**
* @private
*/
this.loaders=new Object();
/**
* The sets an environment variable (make sure it's safe for JS Object[key] notation)
* The idea here is that modules could set this, and pages which load the module
* can then get the Environment variables
* @param k javascript object[key]
* @param v value (technically could be of any type...)
*/
this.setEnv=function(k,v){
this.env[k]=v;
}
/**
* The gets an environment variable previously set
* @param k javascript object[key]
* @returns the value set for this key
*/
this.getEnv=function(k){ return this.env[k];}
/**
* Lists all modules
* loaded in this environment.
* @private
*/
this._loadedJSLoaders=new Object();
/**
* This makes a normalized key to stick into loaded_modules and verify if things are loaded.
* @private
*/
this.normalize=function(m,p,r){ return (m+"__"+p+"__"+r).toLowerCase();};
/**
* This checks whether the given meta/project/release is already loaded.
* @param m metaproject (or the path of a JS file, if no other args are passed)
* @param p project
* @param r release
* @type boolean
* @returns Whether m/p/r is loaded
*/
this.isLoaded=function(m,p,r){
var xkey=this.normalize(m,p,r);
return(this._loadedJSLoaders[xkey]!=null);
};
/**
* Gets a "loader" based on the MPR specified in the arguments
* This is useful for loading subpackages. You can call {@link JSSubLoader#load} or {@link JSSubLoader#loadAll} on this
* and it will load submodules under a folder with the "release" number
* @see JSSubLoader
* @param m metaproject
* @param p project
* @param r release
* @returns void
*/
this.getLoader=function(m,p,r){
var key=this.normalize(m,p,r);
var loader=this.loaders[key];
if(loader) {
return loader;
}
else {
loader=new JSSubLoader(this,this.makeJSLoaderPath(m,p,r,false)+"/");
var __path=this.makePath(m,p,r);
this.setEnv(p.toUpperCase()+"_PATH",__path);
this.loaders[key]=loader;
return loader;
}
}
/**
* Loads the requested module into the environment
* You can also load your own module by calling loadJavascript(url) if you want
* @param m metaproject
* @param p project
* @param r release
* @type boolean
* @returns void
*/
this.load=function(m,p,r){
var key=this.normalize(m,p,r);
var url=this.makeJSLoaderPath(m,p,r,true);
try{
if(this.isLoaded(m,p,r)) {
return;
}
this.loadJavaScript(url);
this._loadedJSLoaders[key]="true";
} catch (e){ this.handleError(e); }
};
/**
* Loads a JavaScript file into the page
* @param {String} url the url of the javascript file
*/
this.loadJavaScript=function (url){
url = this.stripExternalRef(url);
document.writeln("scri"+"pt src='"+url+"' type='text/javascript'/sc"+"ript");
};
/**
* Loads a JavaScript file into the page
* @param {String} url the url of the javascript file
*/
this.loadStyleSheet=function(url){
url = this.stripExternalRef(url);
document.writeln("li"+"nk rel='stylesheet' href='"+url+"' type='text/css'/li"+"nk");
};
/**
* Strips out any double slashes, double dots, or cross domain references.
* @param s string
*/
this.stripExternalRef=function(s){
var exprs = [/\.\.+/g,/\/\/+/g,/\\\\+/g,/\:+/g,/\'+/g,/\%+/g];
// If it's hosted, we relax the protocol related regex
exprs = [/\.\.+/g,/\\\\+/g,/\'+/g,/\%+/g];
if (_remote)
for(var i=0; iexprs.length; i++)
{
s = s.replace(exprs[i], '');
}
return s;
}
/**
* Overwritable error handler
*/
this.handleError=function(e) {
}
return this;
};
/**
* Construct a new JSSubLoader instance. You shoudl never need to call this, as {@link JSLoaderEnvironment#getLoader} gets you one of these from the environment.
* @class JSSubLoader is designed to load "sub" modules
* This is a wrapper which is produced when you call {@link JSLoaderEnvironment#getLoader}
* It is designed to allow sub-packages within a given MPR to be loaded easily. This is constructed by JSLoader.getLoader() call
* so you should never really need to construct one of these.
* @constructor
* @param {JSLoaderEnvironment} env_
* @param {String} prefix_ The path underneath which the submodules reside
*
*/
function JSSubLoader(env_, prefix_){
/**
* @private
*/
this.environment=env_;
/**
* @private
*/
this.prefix=prefix_;
/**
* @private
*/
this.loaded=new Object();
/**
* @private
*/
this.normalize=function(str){ return str.toLowerCase(); }
/**
* Loads an array of subpackages
* @param {Array} pkgs an array of packages.
*/
this.loadAll=function(pkgs_){
for(i=0;ipkgs_.length;++i) this.load(pkgs_[i]);
};
/**
* Loads a subpackage, if it's not already loaded
* @param {String} url the url of the sub-package module file (m/p/r/submodule.js)
*/
this.load=function(pkg){
var p=this.normalize(pkg);
if (this.loaded[p]) {
return;
}
this.loaded[p]=pkg;
this.environment.loadJavaScript(prefix_+pkg+".js");
};
};
JSLoader = new JSLoaderEnvironment();
// LocalWords: fileoverview
