While Looping an Array | 易学教程

问题

I'm trying to understand a book from Don Gosselin on ASP.NET Programming with Visual C#. To solve it I just simply make it to work by adhering to while loops: one while loop is to assign a number to an array element, the other while loop is to display that array. Total array count displays 1 through 100. This should have worked but didn't. Visual Studio 2013 debugger for some reason assigns count = 100, that's why it's failing.

<%
    int count = 0;
    int[] numbers = new int[100];

    while (count <= 100)
    {
        numbers[count] = count;
        ++count;
    }
    while (count <= 100)
    {
        Response.Write(numbers[count] + "<br />");
        ++count;
    }

%>

回答1:

You need to reset the count to 0 before you attempt the next while statement. Currently, the first loop ends when it reaches a count equal to 101. WHen you proceed to the next while, the count is 101 so the loop automatically ends. Just set count = 0; before the second while loop.

回答2:

You should set count to 0 after first while loop:

int count = 0;
int[] numbers = new int[100];

while (count <= 100)
{
    numbers[count] = count;
    ++count;
}
count = 0;
while (count <= 100)
{
    Response.Write(numbers[count] + "<br />");
    ++count;
}

回答3:

This seems like a very convoluted and unrealistic way of using while loops and arrays. In order to understand it better, it may be worth thinking about it per step.

var i = 0;

while (i < 100)
{
    Response.Write(++i + "<br />");
}

The first important distinction is between i++ and ++i. The former utilises the value, and then increments by one; the latter, increments the number and then utilises the value.

In C#, you should really be working with Collections, rather than Arrays. Arrays are zero-indexed, and are renowned for causing serious errors, including exposing potential exploits. Being statically allocated, there is no failsafe when attempting to access indicies outside of the bounds of the Array. Collections, on the other hand, are (for the most part) one-indexed, dynamically allocated, and provide fallbacks when accessing indicies. The most commonly used Collection is a List.

var i = 1;
var list = new List<int>();

while (i <= 100)
{
    list.Add(i++);
}

For the second while loop, it's not really suitable to use a while loop here, for any practical example. The excercise is forcing while loops where they are not needed. In this instance, the aim is to iterate through each element in the array (List) and dump its contents to the screen. Because we want to perform an action for each element, a while loop may cause issues. If the array has less than 100 elements, the program will crash, if the array has more than 100 elements, we'll miss some of them. By using a foreach loop, instead of a while, we can eliminate these potential errors.

foreach (var num in list)
{
    Response.Write(num + "<br />");
}

Now, I realise that the excercise is about while loops, however, it is teaching you to use them in the wrong way. A much better way - and how you'll most often use them - is to perform an action until a particular condition is met, rather than for simple iteration. By this, I mean, a condition is set to false, then inside the while loop, we manipulate a variable, test the condition, and if it's still false, we go round again. The most common example of this is to work out factorials of numbers.

var num = 5;
var factorial = 1;

while (counter > 1)
{
    factorial *= num--;
}

Response.Write(String.Format("{0}! = {1}", input, factorial));

The other main way in which while loops are used is to force an infinite loop, unless a break condition is met. I'll show a very arbitrary use of this here, but a real world example would be the loop() method in Arduino C coding, or a HTTP Listener that constantly repeats the same procedures, until stopped.

var stop = 13;
Response.Write("Pick a number between 1 and 100...<br /><br />");
while (true)
{
    var num = new Random().Next(1, 101);
    Response.Write(num + " ..... ");
    if (num == stop) break;
    Response.Write("You got lucky!<br />");
}
Response.Write("Unlucky for you!);

The best way to learn these things is to practice them. Pick a task and find out just how many ways there are to complete it. There is one last important distinction to mention though. a while loop tests the condition at the beginning of the loop. A do while loop, tests the condition at the end.

while(false)
{
    // This code will never be run.
}

Compared to:

do
{
    // This code will be run once only.
}
while(false)

As a final thought, here's how I'd write the original code (using a LINQ foreach loop):

var numbers = new List<int>();

for (var count = 1; count <= 100; count++)
{
    numbers.Add(count);
}

numbers.ForEach(num => Response.Write(num + "<br />")));

来源：https://stackoverflow.com/questions/26198085/while-looping-an-array

标签

ASP.NET

arrays

while-loop