When the user fills in the page
1. Access the general technology of the ASP collection
Most ASP collections are similar to those of the general set seen in VB. In fact, they are arrays of the value, but can be accessed by using a text string key (for size is not sensitive) and a integer index. Therefore, if the
Firstname:
Lastname:
You can access the values within its control by accessing the ASP's FORM collection:
StrfirstName = Request.form ("firstname")
StrlastName = Request.form ("Lastname")
You can also use the integer index of the control in the form, and the range of index starts from the first defined control in the HTML and then sorted in the defined order:
StrfirstName = Request.form (1)
StrlastName = Request, form (2)
However, this technique is not recommended in the technology that is integrated into indexes, because once there is a change in HTML, or insert a new control, the ASP code will get the wrong value. Further, for those who read the code, it is easy to confuse.
1) All values for access collection
You can turn a series of values on the entire Form into a single character variable by reference collection, without providing a key or index.
StrallFormContent = Request.form
If the text box contains value Priscilla and Descartes, the request.form statement will return the following character:
Firstname = Priscilla & LastName = Descartes
Note that the supplied value is in the form of a name / value (ie, the control name = control value), and each pair of name / values are separated by symbol "&". If it is intended to deliver the content in the form, it is useful to perform an executable application or DLL of the standard format that wants to get the value. However, generally, through the contents of the collection by using the name of the control in the form.
2) Traversing an ASP collection
There are two ways to traverse all members in an ASP collection, and the way is basically the same as the normal VB collection. Each collection provides a count property that returns the number of entries in the collection. You can use the count attribute by using a integer index.
For intloop = 1 to request.form.count
Response.write Request.form & ""
NEXT
If the previous form contains two text boxes of Priscilla and Descartes values, they will get the following results:
Priscilla
Descartes
However, a better way is to use for Each ... NEXT structure.
For Each Objitem in Request.form
Response.write objitem & "=" & required.form (objitem) & "" Next
This has the advantage that it can access the name of the control and access it. The above code will result in the following results:
Firstname = Priscilla
Lastname = descartes
Note that some browser returns to the
3) Multi-value
In some cases, each member in the ASP collection may more than one value, which occurs when there are several controls in the HTML definitions have the same NAME properties. E.g:
In the Form collection, an entry will be created for "OtherHobby". However, it will include the values obtained from the three text boxes. If the user left one or more when submitted, the returned value is an empty string. If the user enters Gardening and Mountaineering, the second text box is empty, and the REQUEST.FORM ("OtherHobBy") is accessed in our ASP code, and the string will return:
Gardening, Mountaineering
In this case, access a single value, you can use complex code:
If Request.form (Objitem) .count> 1 Then 'More Than One Value In this item
Response.Write Objitem & ": "
For intloop = 1 to request.form (Objitem) .count
Response.write "Subkey" & Intloop & "Value =" _
& Request.Form (Objitem) (Intloop) & ""
Else
Response.Write Objitem & "=" & required.form (objitem) & ""
END IF
This will return to the previous form instance containing three OtherHobby controls.
Otherhobby:
Subkey 1 value = gardening
Subkey 2 Value =
Subkey 3 value = mountaineering
However, this technique is rarely used because of the same name, the same name very little.
a) radio or page button control in HTML
In HTML, the case where the same Name property that needs to be given to several controls is a radio (or option) button, for example:
I Live in:
American europe
asia
Because users can only select one of multiple items (this is why the same name is given), it will only be returned, and the browser can only send the value of the selected control. Therefore, if the user of this form has chosen "Europez", this entry will be obtained by traversing the Form set:
Country = EU
Since each control provides a different Value property, the name of the country or region corresponding to each entry is reflected. If the Value property is omitted, the browser will return the value "ON", so you will get:
Country = on
This is not often used, so the VALUE property is usually used for radio controls using the same name.
b) HTML checkbox control
When an HTML source code contains a check box control, the only name is generally given, for example:
I Enjoy:
Reading
Eating
Sleeping
In this case, when the form is submitted, if only the first and third check boxes are selected (marked), the following values are obtained when traversing the FORM collection:
Reading = on
Sleeping = on
However, if a value is provided for each check box, the value is sent to the server instead of the string "ON". For example, the form is as follows:
If except the third check box, all submits, in the Request.form collection, the following results are generated:
Hobby = hobby025, hobby003, hobby010
If you write more complex collection traversal code, as previously described (separately displaying each subkey), you get the result:
It is necessary to pay attention to both cases, and no selected controls are not returned at all. In the first case, there is no spoofing comma, and there is no null value. This is not the same as the results of the above text boxes. When using the text box, each text box returns a value, even an empty string. This is the result of this browser causes this. Therefore, when accessing a collection in the ASP code, pay attention to this problem.
The above situation A tricky negative effect is when using the check box, the index of the check box value is not contacted in the position of the control in the original HTML, and the number of sub-keys of the fourth check box in the above example is 3 Since the second control is not selected when the form is submitted. c) HTML list control
The tag in HTML is used to generate a standard drop-down list box, which is represented in an interesting mix. The following form creates a 5 value for user selection, because the multiple property is included, so you can press the SHIFT or CTRL key by selecting, select the entry not only one.
The following figure shows this page, which is displayed three entries.
This special situation returns a single entry in the Form collection, which contains the selected value (the VALUE attribute specified in a single tag), separated by a comma:
If you use more complex collection traversal code (separately display each subkey), you will get:
Hobby:
Subkey 1 value = hobby025
Subkey 2 value = hobby003
Subkey 3 value = hobby010
This is the same as the same name of the same name as described above. In fact, a SELECT list can be considered a list of column checkbox supplies (not selected) corresponding entries.
However, the list box also has the specified value, if the value is set in the tag, the text content of the selected option will be obtained, and the request.form set will contain such an item:
Hobby = swimming, reading, sleeping
Also, the same, complex collection traversal code will return as follows:
Subkey 1 Value = Swimming
Subkey 2 value = Reading
Subkey 3 value = Sleeping
Of course, if a single item is selected, the value attribute is provided in , resulting in the result contains only:
Hobby = hobby025
If you do not provide a Value property, get:
Hobby = swimming
This allows you to display options for both default (ie, no value) or corresponding changes. The latter case is extremely useful in some cases, if you want to display (a description string) and pass a completely different content (if a short code represents a descriptive string).
d) HTML Submit and Image Controls
The check box and radio box are examples of Boolean controls, select or select Return to "ON", unlike text boxes and most other HTML controls, the browser does not contain the value of the controls that are not selected or not selected.
There is also another commonly used Boolean control called the HTML button. Such as , , , , ... type.
The Button type control does not return any values because it does not have a direct impact on the form. Even if the Submit method used to call the form is used, the browser will not contain the value of the Button Type Control in any request. Similarly, the value of a button will never be sent to the server.
However, the input button control Submit and Image type actually submit the form to the server, its value property contains the value of the other controls of the form (as long as a Name property is included in the HTML definition). For example, this form may be part of a wizard type web application, allowing users to go step by step or cancel process:
In a form, you can include multiple Submit buttons. In this case, you should give each button unique value property, as shown above. When a form is submitted, traversing the value of the Request.Form set will generate a value, depending on which button is pressed to submit this form. If the user presses the "previous" button, you will get:
Btnsubmit = previous
Therefore, you can query the Request.form collection to determine the next page, for example:
Select Case Request.form ("btnsubmit")
Case "Next"
Response.Redirect "Page_3.asp"
Case "previous"
Response.Redirect "Page_1.asp"
Case "ca Zancel"
Response.Redirect "main_menu.asp"
End SELECT
At the same time, different Name properties can also be used for each button as needed. And select its value containing the name of the control in the Form collection. In the case where the control does not have a complete tag, it is then extremely useful, as shown in the following figure.
The interface on this screen is generated by the following code:
what do you want to do now?
If Len ("BTnPRevious")) "Page_1.asp"
If Len ("BTNCANCEL")) "Main_Menu.asp" This is the ASP collection on a key. If there is no existence, it returns an empty string. In other words, if the second button (Previous page) is pressed, the value of Request.form ("BTnNext") is an empty string, and its length is zero without generating an error. When the second button is pressed, the value of this entry in the Form collection is "" "" "" "" "" "" "" "" "" "" "" "" "" "
e) improve the efficiency of using the Request collection
Access an ASP collection to download a value of time to calculate the resource, because this operation contains a series of searches for related collections, which is much slower than accessing a local variable. Therefore, if you plan to use a value in the collection multiple times in the page, you should consider storing it into a local variable, for example:
Strtitle = Request.form ("Title")
If len (sttitle) dam = strtitle & ""
If strfirstname = "" ""
Strfullname = strtitle & "& strlastname
Elseif len (strfirstname) = 1 THEN
Strfullname = starts & strfirstname & "·" & strlastname
Strfullname = starte & strfirstname & "& strlastname
f) Search all Request collection
In some cases, it may be known that a value of the key name will appear in the Request collection, but it cannot be accurately known which collection is. For example, if there are several pages (or different segments of a page) send a value to the same ASP script, it may appear in the Form or querystring collection.
The following sections will study the differences in FORM and QueryString collections.
To see why a value may appear in different collections, consider this situation: Use the Super Link Element to request a page. In this case, the only way to add a value to the request is to add it to the URL. However, the same value may have appeared in the of another page, or different parts of the same page:
...
For help go to the Help Page
In this case, press the HELP button on the form to send a pair of name / value "Page = Help" in the Request.Form collection. However, pressing the hyperlink may also send the name / value "page = help", but this time is in the querystring collection. To access this value, you can use a special feature of the ASP Request object: strpage = request ("page")
This will search all sets in sequentially - QueryString, Form, Cookies, ClientCertificate, ServerVariables until the name of the first match value is found. This is lower than that of directly accessing appropriate collection efficiency, and is unsafe, unless it is absolutely guaranteed that this value does not appear in another collection.
For example, it may be desirable to collect the name of the web server that meets the client request, which is implemented in the Request.ServerVariables collection in each query. However, if any other collection also includes a value called "server_name" (remember the key name is not case sensitive), when using Request ("Server_Name"), the result is the result of the error. Using the REQEUST.SERVARVARIABLES ("Server_Name" syntax, we will be difficult to track.
All in all, using the "Search All Collection" technology should be taken particularly careful, and only when there is no other technique to provide the results you need.
g) Access to other collections
In this section of this chapter, the Form collection has been discussed, which may be one of the most used. However, all of these techniques are equally applicable to other objects. Includes those set by the Request object (ie form, querystring, cookies, servervariables, and clientpertate), and cookies provided by the Response object (and other objects that will be encountered in the next chapter).
We will briefly understand how a value enters a queryString collection, and its advantages and deficiencies. However, this two cookies sets have additional features that can be easier to use cookies, discuss this content below.
Access and update cookies collection
The value of cookies is much more complicated than other values of the ASP (such as Form and ServerVariables). Cookie is a small piece of text stored on the client system by the browser and serve the servers in the domain that are applied each time.
The ASP makes it easier to apply cookies, and you can get all the cookie values emitted with the request from the cookies collection of the Request object, and create or modify the cookie, send back to the user from the Cookies collection through the Response object.
The cookie contains information that can be constructed in two ways, and the single-valued cookie provides its value to the code through a general class ASP collection. However, each member of the collection may also be a collection, including the cookie of this information, by the multiple-value cookie.
Creating a single-value cookie is simpler, as shown below:
Response.cookies ("item-name") = "item-value"
Create a multi-value cookie, you can use the following command:
Response.cookies ("item-name") ("sub-item-name") = "Sub-item-value"
Set the domains and paths of the cookie app and its validity period, we use:
Response.cookies ("item-name"). Domain = "domain-url" response.cookies ("item-name"). Path = "Virtual-path"
Response.cookies ("item-name"). Expires = # Date #
Typically, the customer only disrespects the server when requested by the page in a directory in the cookie. By specifying the PATH property, you can specify where this cookie is legal, and this cookie will send it with the request. If the cookie is sent with the page requesting the entire site, set the PATH to "/".
If the Expires property is not set, the Cookie will be automatically eliminated when the current browser instance is turned off.
Note that when we send any output to your browser, we have created a cookie. Because these cookies are part of the page HTTP header.
In ASP 3.0, the buffered default state is open, and no output is sent unless you use Response.flush to specify this work or the page has arrived at the end. This means that creating cookie's code can be executed anywhere on the page until any output "refresh" (FLUSH) to the client, it can be performed.
To read existing cookies, use the Request.Cookies collection. You can access the items alone, and the method is similar to the method used when you create them.
StrsingLevalue = Request.Cookies ("item-name")
STRSUBITEMVALUE = Request.Cookies ("Item-name") ("Sub-item-name")
Note that the Request.Cookies collection (like all other Request collection) is read-only. The Response.Cookies collection is only written, in fact, you can access a series of cookies in this collection instead of their value.
Traversing cookies collection
To make it easier to use the cookies collection, additional properties named Haskeys can be used. If the visiting cookie itself is also a collection, that is, it is a multi-value cookie, which will return True. Use the Haskeys property to traverse the full Request.Cookies collection to get all the cookies lists and their values.
For Each Objitem in Request.cookies
If Request.cookies (Objitem). Haskey Then
'Use Another for Each To Itereate All Subkeys
For Each Objitemkey in Request.Cookies (Objitem)
Response.Write Objitem & "(" & objitemkey & ") =" _
& Request.Cookies (ObjitemKey) & ""
'Print Out the cookie string as normal
Response.Write Objitem & "=" & required.cookies (objitem) & ""
This is very similar to complex code for extracting multiple values from the Request.form collection. However, here you can use the Haskeys property to determine if each entry is a collection. In the Form example, you must query the Request.form (item_name) .count property, because the Form collection (and all the other collections outside Cookie) cannot be a real collection. The ASP just did the "behind the scene" and got a value of each multi-purpose collection. Differences in Form and QueryString
After understanding the technology of accessing various ASP collections, you need to solve another problem is: What is the difference between Form and QueryString collections? If you are ready to use ASP, there is no doubt that this difference should be clear, but you need to refer to HTTP's way to re-understand and understand them.
Request page or other resource from the web server via HTTP, there are two universal methods. You can use the GET method to get resources directly, or you can pass the value to the corresponding resources using the POST. The GET method is default, you can see an instance of an HTTP request in front of this chapter:
7/8/99 10:27:16 Sent Get Get /Store/download.asp http / 1.1
If one or more paired names / values are attached to the URL of the request page, turn it into a request query string and is provided to the ASP page in the queryString collection. Click the hyperlink of web pages, email messages, or other documents, or enter your address in the browser's address bar and press Enter, or click the Links or Favorites button in your browser. All of this uses the GET method.
Therefore, the only way to transmit the value to the ASP in these actions is to attach the value to the URL through the queryString collection.
The value in the request.QueryString collection is also accessed, the same work in the form of the Form collection instance you see. Combination of URL and query strings:
Http://mysite.com/process_page.asp?firstname=priscilla&lastname=descartes
You can use the following way to access the values provided in the querystring collection:
StrfirstName = Request.QueryString ("firstname") 'Return "Prismilla"
StrlastName = Request.QueryString ("Lastname") 'Return "Descartes"
Strraw = request.queryString
'Return "firstname = priscilla & lastname = descartes"
Form GET and POST method
When using the
When this request arrives at the web server, its value is provided by the ASP's request.QueryString collection. However, if the Method property is set to "POST", the browser packages the value package into the HTTP header of the sending server, supplied to the ASP via the Request.form collection.
By, you can use the Post method in all HTML forms. However, there is a certain limit for the URL string of the browser or server. Therefore, a long string may cause overflow and characters of some strings to be cut off. At the same time, the query string appears in the address bar of the browser and all saved links and favorites. Not only that, but also revealing the value that does not want to display in the HTTP request through the web server, which may also have a log file of your server and other routing servers. The value in the HTTP request header is very visible and does not appear in the log file. Small problems you need to pay attention to using the POST method is that when the user re-downloads
Another point is that the combination of the URL and the query string cannot contain any spaces or other illegal characters, otherwise, Navigator and some other browsers will have problems. Illegal characters are portions that are used to secure the URL and query strings, such as "/", ":", "?" And "&" (IE can automatically convert space to the correct format - plus " ", But other illegal characters cannot be processed). ASP server object provides URLENCode method to process this transformation, and later discuss the relevant content.
View Request and Response object content
At present, some of the theoretical issues are mainly discussed, and there is no special example. It is closely related to each other in most cases that have been discussed. However, this book provides a series of examples of examples for this chapter, which shows most of the req Request and Response objects. Applications can understand these pages and can be modified to use them as a test example.
The sample samples of this chapter and all other chapters are provided to the user, and can be downloaded from the Wrox Press Site Site.
http://webdev.wrox.co.uk/books/2610
http://www.wrox.com/store/details.asp?code=2610
You must first install the instance in subdirectory within the WEB server wwwroot, then use the browser to access the Chapter02 subdirectory, use:
http: //your_server_name_or_ip/subdirectory_name/chapter02/default.asp
Here Your_server_name_or_ip / subdirectory_name is the local path to install the download file.
1, see the Request object member
This provides a menu containing the page to test the Request and Response objects, first select Using The Request Object, as shown below:
The figure below shows an instance of an HTML form that contains some pre-set values, you can edit these values according to your own ideas, then click the "Submit" button.
This will open a page, as shown in the following figure, display the full content of the collection and Totalbytes properties. The first screen is displayed for Form, QueryString, and Cookies collection.
Note that if the value of the HTML control is edited in the form page, different values may be displayed on the page on the reader's computer for the cookies collection and other collections.
You can see how the value of the HTML control on the form from the "Form Collection" segment is indicated in the ASP's Request.form collection. You can also test and detect with the original
A list of all ServerVariables collection members, and their values are available in the back appendix. However, these members can be seen from the client from the client when the request page is discussed previously. When the request is received, the web server also adds some of its own values to the collection, as you can see above, as you can see.
1) How is the page work?
In order to create this page, the exact same code seen in front of this chapter in the discussion of the Form set and how to access its value. For example, traverse all sets (outside of Request.cookies), use:
For Each Objitem in Request.collection_name
Response.Write Objitem & "=" & required.collection_name (objitem) & ""
Traverse the cookies collection, you can use:
If Request.cookies (Objitem). Haskeys then
'Use another for ... Each to Itereate All Keys of Dictionary
Resonse.Write Objitem Objitem & "(" & objitemKey & ") =" _
To get TOTALBYTES properties, you can use it simply:
Request.totalbytes = <% = request.totalbytes%>
Readers should notice that certain values that appear in both collections are not directly obtained from the HTML controls of the form. QueryString set includes two values called Chapter and Sample, as shown below:
To create these two values in the request, attach a string on the URL of the form of the action attribute, which is acceptable. The working mode is similar to the HREF attribute attached to a element. The value of the query character appears in the querystring collection, and the value of the POST has appeared in the Form collection.
To prevent an error in the browser in non-IE class, the space in the query string must be replaced by the plus " ", and the reader will see more in the Urlencode method of the Server object in Chapter 4. 2) Create a client's cookie
In order to ensure that at least some value appears in the Request.Cookies collection, add some client script code to the original
This is a client code for setting the cookies property of the document object when the form is loaded:
