The randomAlphaNumeric() function doesn't always return a full data set with a minimum of 1 of each possible characters. Basically I want to ensure we get at least 1 of each range: 0-9, a-z, and A-Z.

In some cases I was getting only numbers, or only UPPER with numbers. I've worked around it with the below function, which I'm sure is probably the wrong way to do this, but it works for now.

// Greg Fischer - guaranteed full data set of a-z A-Z and 0-9
String randomAlphaNumericFullSet(int length){
	String x = randomAlphaNumeric(length);
	bool z = false;
	while (z == false) {
		//print('Assessing X: ${x}');
		if(x.contains(new RegExp(r'[a-z]'))
			&& x.contains(new RegExp(r'[A-Z]'))
			&& x.contains(new RegExp(r'[0-9]'))
		){
			// print('contains a-z A-Z and 0-9 : ${x}');
			z = true;
		}
		else {
			x = randomAlphaNumeric(length);
		}
	}
	return x;
}

I have -> added this package - random_string: ^2.0.1 in pubsec.yaml file -> pub.get ->import 'package:random_string/random_string.dart'; [this line gives error]

I have attached the images ---

Because you first randomly choose how many characters are numeric and how many are alphanumeric, numerical characters are 4.8 (48/10) times as likely to occur then alphas. This reduces entropy, and thus increases collision probability (the total space of available strings stays the same).

I would actually suggest to move away from the current ascii based approach as this is very easy to get wrong in some minor way and move to charsets as this seems far simpler and thus robust.

this is my current internal implementation:

const alphaNumericCharSet =
    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

String randomAlphaNumeric(int length) =>
    randomStringForCharset(length, alphaNumericCharSet);

String randomStringForCharset(int length, String charset) {
  final random = Random();
  return [
    for (var i = 0; i < length; i++) charset[random.nextInt(charset.length)]
  ].join();
}

I could also create a merge request for this

Note that no code changes are necessary for null-safety. The only issue was related to the tests, but a minor small adjustment was able to negate any need to add a nullable type. So when the time comes to adopt null-safety, it is purely a compiler option.

Updated the package version and changelog,

0.0.2

• Added Support for Dart 2
• Fixed Error: The argument type 'dart.core::List'

Also, would be nice if you could upload/update https://pub.dartlang.org/packages/random_string or add me as an uploader ([email protected])

Not sure if you are maintaining this but I tried it in a test and got:

compiler message: file:///Users/dking5/flutter/.pub-cache/hosted/pub.dartlang.org/random_string-0.0.1/lib/random_string.dart:76:35: Error: A value of type 'dart.core::List' can't be assigned to a variable of type 'dart.core::Iterabledart.core::int'. compiler message: Try changing the type of the left hand side, or casting the right hand side to 'dart.core::Iterabledart.core::int'. compiler message: return new String.fromCharCodes(mergedCodeUnits); compiler message: ^

Hi. The Provider package is one of the most popular state management solutions available for Flutter, but we can't use it along with your package because there is a conflict, since you define the same name 'Provider'. In most cases it is not possible to stop using Provider, so we end up unistalling your package. Maybe change it so there are no conflicts in future versions?

Error below:

error: The name 'Provider' is defined in the libraries 'package:provider/src/provider.dart' and 'package:random_string/random_string.dart'. (ambiguous_import at [my_surgery] lib/screens/import_view.dart:124)

Thanks.

The current implementation of randomBetween (as of 2.0.1) is:

int randomBetween(int from, int to,
    {AbstractRandomProvider provider = const DefaultRandomProvider()}) {
  if (from > to) throw Exception('$from cannot be > $to');
  var randomDouble = provider.nextDouble();
  if (randomDouble < 0) randomDouble *= -1;
  if (randomDouble > 1) randomDouble = 1 / randomDouble;
  return ((to - from) * provider.nextDouble()).toInt() + from;
}

I see a few problems:

• The documentation claims that the returned value should be in the range [from, to]. As implemented, however, if from != to, it can return values only in the range [from, to). The (to - from) factor should be (to - from + 1) to use an inclusive upper-bound. Consider a simple case of randomBetween(0, 1) where you want 2 possible values: Since toInt() truncates (rounds to 0), you ultimately want a double in the range [0, 2) so that toInt() can return an integer in the range [0, 1]. Assuming that provider.nextDouble() returns a fraction in the range [0, 1), you therefore must scale it by 2. Alternatively change the documented behavior. (The existing test to verify that randomBetween can return the inclusive upper-bound happens to work because it ends up being a degenerate case.)

• randomBetween unnecessarily calls provider.nextDouble twice. It computes an adjusted randomDouble value but then proceeds to ignore it.

• I see no documentation from AbstractRandomProvider specifying what nextDouble should return. Random.nextDouble from dart:math returns a value in the range [0, 1), but it's unclear what expectation AbstractRandomProvider has. This is a problem because:

• That randomBetween tolerates provider.nextDouble() returning double values < 0 or > 1 suggests that any finite double values are legal. However, that could cause randomBetween to return random numbers without a uniform distribution, even if provider does have a uniform distribution. For example, suppose an AbstractRandomProvider is given whose nextDouble implementation returns a random double in the range [0, 100) with a uniform distribution, and suppose that we call randomBetween(0, 1, provider: myProvider). If randomDouble returns a value > 2 (which would happen 98% of the time), the > 1 check would adjust randomDouble to be < 0.5. Assuming that randomDouble were used in the final calculation instead of calling provider.nextDouble() again, this would give an undue weight to returning 0 instead of 1. I suggest:

  1. If provider.nextDouble returns a value outside the expected range, either fail or retry. Do not try to coerce it into the expected range because doing so is likely to change its distribution.
  2. Document that AbstractRandomProvider.nextDouble must return values in the range [0, 1).

What was the problem?

Data type error could, also could not compile for sdk 2.0 and above

How did I fix it?

Changed List<dynamic> to List<int> for dart.core::Iterable<dart.core::int> Changed environment sdk to <3.0