QA@IT
«回答へ戻る

nextprocの名前をresposewaitに変更

5599
 
 現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
 例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
-xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(nextproc)
+xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(resposewait)
 
 ```javascript
 var resultHash = new Object();
     return hashkey.toString();
 }
 
-function nextproc(hashkey){
+function resposewait(hashkey){
     if(resultHash[hashkey] == undefined){
-        setTimeout("nextproc(" + hashkey + ")", 500);
+        setTimeout("resposewait(" + hashkey + ")", 500);
     }else{
         return resultHash[hashkey];
     }
 }
 
 var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
-var doc = nextproc(hashkey);
+var doc = resposewait(hashkey);
 console.log(doc);
 ```
 
 ```javascript
 
 var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
-var document = nextproc(hashkey);
+var document = resposewait(hashkey);
 var element = document.getElementById("toptxt");
 console.log(element.innerHTML);
 var childElement = element.getElementsByTagName("a");
 console.log(childElement[0].href);
 
 hashkey = xhrStart('GET',childElement[0].href);
-document = nextproc(hashkey);
+document = resposewait(hashkey);
 var innerElement = document.getElementsByTagName("a");
 console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
 

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(resposewait)

var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function resposewait(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("resposewait(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = resposewait(hashkey);
console.log(doc);

例えばこれを使うと


var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = resposewait(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = resposewait(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略

といったコードがかけるかと思います。


別の方法として、現在は「xhrStartの結果を受け取って、メイン処理を継続する」という発想に立っていますが、「xhrStartに続きの処理も引き渡しておく」という考え方もあります。
個人的にはこちらの方がajaxらしく見える気もします(元々がコールバック関数を受け取るオブジェクトだからでしょうが)。

// 引数にコールバック関数(response後にやってほしい続きの処理)を増やす
function xhrStart(method,url,data,RequestHeader, callback){
    var xhr = new XMLHttpRequest();

    xhr.onload = function(){
        // 続きの処理を呼び出す
        callback(xhr.response);
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);
}

// callback1 で使うので先に書いてある。
var callback2 = function(document) {
    var innerElement = document.getElementsByTagName("a");
    console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
}

var callback1 = function(document) {
    var element = document.getElementById("toptxt");  
    console.log(element.innerHTML);
    var childElement = element.getElementsByTagName("a");
    console.log(childElement[0].href);

    hashkey = xhrStart('GET',childElement[0].href, null,null, callback2);
}

// 最後の引数にコールバック関数を渡す
xhrStart('GET','http://www.yahoo.co.jp/',null,null,callback1);

上記の様な構成もとれる。ということで確認は簡単にしかしていませんが参考にどうぞ。

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

```javascript
function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));
```

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(resposewait)

```javascript
var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function resposewait(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("resposewait(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = resposewait(hashkey);
console.log(doc);
```

例えばこれを使うと

```javascript

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = resposewait(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = resposewait(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略
```

といったコードがかけるかと思います。

---

別の方法として、現在は「xhrStartの結果を受け取って、メイン処理を継続する」という発想に立っていますが、「xhrStartに続きの処理も引き渡しておく」という考え方もあります。
個人的にはこちらの方がajaxらしく見える気もします(元々がコールバック関数を受け取るオブジェクトだからでしょうが)。

```javascript
// 引数にコールバック関数(response後にやってほしい続きの処理)を増やす
function xhrStart(method,url,data,RequestHeader, callback){
    var xhr = new XMLHttpRequest();

    xhr.onload = function(){
        // 続きの処理を呼び出す
        callback(xhr.response);
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);
}

// callback1 で使うので先に書いてある。
var callback2 = function(document) {
    var innerElement = document.getElementsByTagName("a");
    console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
}

var callback1 = function(document) {
    var element = document.getElementById("toptxt");  
    console.log(element.innerHTML);
    var childElement = element.getElementsByTagName("a");
    console.log(childElement[0].href);

    hashkey = xhrStart('GET',childElement[0].href, null,null, callback2);
}

// 最後の引数にコールバック関数を渡す
xhrStart('GET','http://www.yahoo.co.jp/',null,null,callback1);
```

上記の様な構成もとれる。ということで確認は簡単にしかしていませんが参考にどうぞ。

5599
 
 ---
 
-もう少し続きますが一旦投稿します。
+別の方法として、現在は「xhrStartの結果を受け取って、メイン処理を継続する」という発想に立っていますが、「xhrStartに続きの処理も引き渡しておく」という考え方もあります。
+個人的にはこちらの方がajaxらしく見える気もします(元々がコールバック関数を受け取るオブジェクトだからでしょうが)。
+
+```javascript
+// 引数にコールバック関数(response後にやってほしい続きの処理)を増やす
+function xhrStart(method,url,data,RequestHeader, callback){
+    var xhr = new XMLHttpRequest();
+
+    xhr.onload = function(){
+        // 続きの処理を呼び出す
+        callback(xhr.response);
+    }
+
+    xhr.open(method,url); // 非同期
+    if(RequestHeader != null){
+        for(key in RequestHeader){
+            xhr.setRequestHeader(key,RequestHeader[key]);
+        }
+    }
+    xhr.responseType = "document";
+
+    if(method === 'GET')
+        xhr.send(null);
+    else
+        xhr.send(data);
+}
+
+// callback1 で使うので先に書いてある。
+var callback2 = function(document) {
+    var innerElement = document.getElementsByTagName("a");
+    console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
+}
+
+var callback1 = function(document) {
+    var element = document.getElementById("toptxt");  
+    console.log(element.innerHTML);
+    var childElement = element.getElementsByTagName("a");
+    console.log(childElement[0].href);
+
+    hashkey = xhrStart('GET',childElement[0].href, null,null, callback2);
+}
+
+// 最後の引数にコールバック関数を渡す
+xhrStart('GET','http://www.yahoo.co.jp/',null,null,callback1);
+```
+
+上記の様な構成もとれる。ということで確認は簡単にしかしていませんが参考にどうぞ。

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(nextproc)

var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function nextproc(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("nextproc(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = nextproc(hashkey);
console.log(doc);

例えばこれを使うと


var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = nextproc(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = nextproc(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略

といったコードがかけるかと思います。


別の方法として、現在は「xhrStartの結果を受け取って、メイン処理を継続する」という発想に立っていますが、「xhrStartに続きの処理も引き渡しておく」という考え方もあります。
個人的にはこちらの方がajaxらしく見える気もします(元々がコールバック関数を受け取るオブジェクトだからでしょうが)。

// 引数にコールバック関数(response後にやってほしい続きの処理)を増やす
function xhrStart(method,url,data,RequestHeader, callback){
    var xhr = new XMLHttpRequest();

    xhr.onload = function(){
        // 続きの処理を呼び出す
        callback(xhr.response);
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);
}

// callback1 で使うので先に書いてある。
var callback2 = function(document) {
    var innerElement = document.getElementsByTagName("a");
    console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
}

var callback1 = function(document) {
    var element = document.getElementById("toptxt");  
    console.log(element.innerHTML);
    var childElement = element.getElementsByTagName("a");
    console.log(childElement[0].href);

    hashkey = xhrStart('GET',childElement[0].href, null,null, callback2);
}

// 最後の引数にコールバック関数を渡す
xhrStart('GET','http://www.yahoo.co.jp/',null,null,callback1);

上記の様な構成もとれる。ということで確認は簡単にしかしていませんが参考にどうぞ。

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

```javascript
function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));
```

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(nextproc)

```javascript
var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function nextproc(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("nextproc(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = nextproc(hashkey);
console.log(doc);
```

例えばこれを使うと

```javascript

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = nextproc(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = nextproc(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略
```

といったコードがかけるかと思います。

---

別の方法として、現在は「xhrStartの結果を受け取って、メイン処理を継続する」という発想に立っていますが、「xhrStartに続きの処理も引き渡しておく」という考え方もあります。
個人的にはこちらの方がajaxらしく見える気もします(元々がコールバック関数を受け取るオブジェクトだからでしょうが)。

```javascript
// 引数にコールバック関数(response後にやってほしい続きの処理)を増やす
function xhrStart(method,url,data,RequestHeader, callback){
    var xhr = new XMLHttpRequest();

    xhr.onload = function(){
        // 続きの処理を呼び出す
        callback(xhr.response);
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);
}

// callback1 で使うので先に書いてある。
var callback2 = function(document) {
    var innerElement = document.getElementsByTagName("a");
    console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);
}

var callback1 = function(document) {
    var element = document.getElementById("toptxt");  
    console.log(element.innerHTML);
    var childElement = element.getElementsByTagName("a");
    console.log(childElement[0].href);

    hashkey = xhrStart('GET',childElement[0].href, null,null, callback2);
}

// 最後の引数にコールバック関数を渡す
xhrStart('GET','http://www.yahoo.co.jp/',null,null,callback1);
```

上記の様な構成もとれる。ということで確認は簡単にしかしていませんが参考にどうぞ。

回答を投稿

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(nextproc)

var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function nextproc(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("nextproc(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = nextproc(hashkey);
console.log(doc);

例えばこれを使うと


var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = nextproc(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = nextproc(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略

といったコードがかけるかと思います。


もう少し続きますが一旦投稿します。

クロスドメインの問題はおいておきますが(これ自体はクロスドメインのjsonpの様に別サーバー挟むという手はあるにはありますけどね)、

とりあえず非同期と同期ではアプローチの仕方が異なります。
厳密にはいろいろあるのですが誤解を恐れず言えば、「戻り値を受け取る」と考えた時点でそれは同期処理です。

それでも非同期処理で戻り値を受け取りたいのであれば、戻り値となりうる値が手に入るまで待つ(たとえば単純にsleepなどして)というのが考えられ、
例えば以下の様な処理を思いつきます(が、以下は動きません)。

```javascript
function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();
    var response = undefined;
    var onload_processed = false;

    xhr.onload = function(){
        onload_processed = true;
        response = xhr.response;
    }   
    xhr.open(method,url);
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";
    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    while(!onload_processed){
        sleep(100);  // javascript に sleepはなく、busy waitさせるとajax 側に影響がでる場合もある
    }

    return response;
}

console.log(xhrStart('GET','http://www.yahoo.co.jp/'));
```

現状の javascriptはその場で待つ処理が苦手ですので、何か別の手立てで待つ必要があります。
例えば以下の様に連想配列を用意し、xhrStartでは格納予定のキーを返し、
xhrStartを呼び出した方はそのキーを元に連想配列が変化するかどうかを一定間隔で確認します(nextproc)

```javascript
var resultHash = new Object();

function xhrStart(method,url,data,RequestHeader){
    var xhr = new XMLHttpRequest();

    var hashkey = new Date().getTime();
    xhr.onload = function(){
        resultHash[hashkey] = xhr.response;
    }

    xhr.open(method,url); // 非同期
    if(RequestHeader != null){
        for(key in RequestHeader){
            xhr.setRequestHeader(key,RequestHeader[key]);
        }
    }
    xhr.responseType = "document";

    if(method === 'GET')
        xhr.send(null);
    else
        xhr.send(data);

    return hashkey.toString();
}

function nextproc(hashkey){
    if(resultHash[hashkey] == undefined){
        setTimeout("nextproc(" + hashkey + ")", 500);
    }else{
        return resultHash[hashkey];
    }
}

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var doc = nextproc(hashkey);
console.log(doc);
```

例えばこれを使うと

```javascript

var hashkey = xhrStart('GET','http://www.yahoo.co.jp/');
var document = nextproc(hashkey);
var element = document.getElementById("toptxt");
console.log(element.innerHTML);
var childElement = element.getElementsByTagName("a");
console.log(childElement[0].href);

hashkey = xhrStart('GET',childElement[0].href);
document = nextproc(hashkey);
var innerElement = document.getElementsByTagName("a");
console.log(innerElement[Math.floor(Math.random() * innerElement.length)].href);

// 以下略
```

といったコードがかけるかと思います。

---

もう少し続きますが一旦投稿します。