Yahoo! search interface: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program yahoosearch64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program yahoosearch.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

=={{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)]'''

 

 

The regular expression used below was figured out by studying the raw HTML and works fine as at 18th November, 2019.

 

import (

fmt.Println(res)

}

 

{{out}}

=={{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}}

=={{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:

YahooSearch.rakumod:

 

use Gumbo;

use LWP::Simple;

YahooSearch.new($search-term).results.next.results;

}

 

And the invocation script is simply:

 

Should give out something like the following:

=== #1 ===

Title:

URL: https://video.search.yahoo.com/search/video?p=test

Text: More Test videos

 

...and should go up to result #21!

{{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.}}