Yahoo! search interface: Difference between revisions

It must implement a '''Next Page''' method, and read URL, Title and Content from results.

<br><br>

 

=={{header|AutoHotkey}}==

translated from python example

yahooSearch("test", 1)

yahooSearch("test", 2)

url := regexreplace(url, "<.*?>")

return url

 

=={{header|C sharp}}==

E. g. all implementations for this task which regex for

"<a class=" fail by now, after Yahoo has changed its output format.

using System.Net;

using System.Text.RegularExpressions;

}

}

 

=={{header|D}}==

{{trans|C#}}

std.net.curl;

 

void main() {

writefln("%(%s\n%)", "test".YahooSearch.results);

{{out|Output (shortened)}}

<pre>

 

=={{header|Gambas}}==

Dim hWebView As WebView

 

hWebView.URL = "https://www.yahoo.com"

 

'''[http://www.cogier.com/gambas/Yahoo!%20search%20interface.png Click here to see output (I have typed 'rosettacode' in the search box)]'''

 

=={{header|GUISS}}==

 

 

=={{header|Haskell}}==

Haskell is not an object oriented language, so this example does not implement an object class.

However, it can be interesting as an example of how HTML source code can be parsed using the Parsec library.

import Text.Parsec

 

in [ YahooSearchItem { itemUrl = u, itemTitle = t, itemContent = c } |

(u, t, c) <- zip3 us ts cs ]

Simple invocation from GHCi: <pre>yahoo "Rosetta%20code" >>= printResults</pre>. Notice that spaces must be expressed as "%20", because spaces are not allowed in URLs.

==Icon and {{header|Unicon}}==

The following uses the Unicon pre-processor and messaging extensions and won't run under Icon without significant modification.

The code provides a suitable demonstration; however, could be made more robust by things such as URL escaping the search string

 

procedure main()

urlpat := sprintf("http://search.yahoo.com/search?p=%s&b=%%d",searchtext)

page := 0

 

{{libheader|Icon Programming Library}}

osettaCode</b>) CALL transfers control to the first statement of a SUBROUTINE. C

ALL subroutine_name[argument1, ..."</pre>

=={{header|Java}}==

{{incorrect|Java}}

import java.io.IOException;

import java.io.InputStreamReader;

}

}

=={{header|Kotlin}}==

{{incorrect|Kotlin}}

This is based on the C# entry but uses a regular expression based on what appears to be the Yahoo! format as at the date of this entry (4 December 2017).

 

import java.net.URL

for (result in x.results.take(3)) println(result)

}

Output (restricted to first three results on first two pages):

<pre>PAGE 1 =>

Text : Last week Christian Drumm (@ceedee666) and Fred Verheul (@fredverheul) had a short conversation on ...</pre>

 

We cannot define a class in Mathematica, so I generate a "Manipulate" object instead.

Column[Flatten[

StringCases[

Row[{Button["Search", page = 1; query = input],

Button["Prev", page -= 10, Enabled -> Dynamic[page >= 10]],

 

=={{header|Oz}}==

 

We implement some simple parsing with logic programming. Regular expressions in Oz don't seem to support lazy quantification which makes parsing the result pages with them difficult.

[HTTPClient] = {Module.link ['x-ozlib://mesaros/net/HTTPClient.ozf']}

[StringX] = {Module.link ['x-oz://system/String.ozf']}

end

in

 

=={{header|Perl}}==

 

use Encode;

$invocant->{link_to_next} = $next;

$invocant->{results} = $results;

 

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

 

(de yahoo (Query Page)

(T (eof))

(T (= "</div" (till ">" T)))

Output:

<pre>: (more (yahoo "test"))

 

=={{header|Python}}==

import re

 

for result in x.search_results:

 

=={{header|R}}==

 

Rather than using regexes to find the content (like some of the other solutions here) this method parses the HTML and finds the appropriate sections.

{

if(!require(RCurl) || !require(XML))

#Usage

YahooSearch("rosetta code")

 

=={{header|Racket}}==

(require net/url)

(define *yaho-url* "http://search.yahoo.com/search?p=~a&b=~a")

(define (next-page)

(set! *current-page* (add1 *current-page*))

 

# REPL:

Text: Whether your are playing Greek number mode or Egyptian letter mode, the number one rule to keep in mind is keeping the scales balanced but its not that ...

</pre>

=={{header|Ruby}}==

{{improve|1=Ruby|2=Should not call <code>URI.escape</code>, because it fails to encode = signs and some other characters that might appear in the term. See [[URL encoding#Ruby]].}}

Uses {{libheader|RubyGems}} {{libheader|Hpricot}} to parse the HTML. Someone more skillful than I at XPath or CSS could tighten up the <code>parse_html</code> method.

require 'hpricot'

 

puts result.content

puts

 

=={{header|Run BASIC}}==

' send this from the server to the clients browser

'--------------------------------------------------------------------------

[exit]

cls ' clear browser screen and get outta here

This user input sits at the top of the yahoo page so they can select a new search or page

<div>[[File:yahooSearchRunBasic.png‎]]</div>

{{trans|Python}}

 

 

proc fix s {

foreach {title content url} [Nextpage] {

puts $title

{{works with|Tcl|8.6}}

With Tcl 8.6, more options are available for managing the global state, through objects and coroutines. First, an object-based solution that takes the basic <tt>YahooSearch</tt> functionality and dresses it up to be more Tcl-like:

 

oo::class create WebSearcher {

puts "\"$title\" : $url"

}

However, the paradigm of an iterator is also interesting and is more appropriately supported through a coroutine. This version conceals the fact that the service produces output in pages; care should be taken with it because it can produce rather a lot of network traffic...

 

proc yahoo! term {

puts [dict get [$it] title]

after 300 ;# Slow the code down... :-)

 

Another approach: uses a class as specified in the task. Also, uses an html parser from tcllib (parsing html with regular expressions is a particular annoyance of [[User:Glennj|mine]]).

{{tcllib|htmlparse}}

{{tcllib|textutil::adjust}}<!-- for formatting output -->

package require http

package require htmlparse

puts ""

}

 

=={{header|TXR}}==

A little sprinkling of regex is used.

 

@(next :args)

@(cases)

@ (end)

@(end)

 

Sample run:

</pre>

 

 

{{omit from|Batch File|Does not have network access.}}

{{omit from|Brlcad}}

{{omit from|Lilypond}}

{{omit from|Locomotive Basic|Does not have network access.}}