js远程程序,程序员远程

本文目录一览：

• 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