private namespace rss;
private namespace xml;
    
public function ErrorExamples() {
 	use namespace rss;
 	use namespace xml;
	trace(hello());
}
    
rss function hello():String {
 	return "hola";
 }
    
 xml function hello():String {
 return "foo";
    }

Corrigez une référence ambiguë en la rendant spécifique. L'exemple suivant a la forme espace de nom::fonction pour spécifier l'espace de noms à utiliser :

public function ErrorExamples() {
    
 trace(rss::hello());
 trace(xml::hello());
}

public override function foo():void{};

Une erreur peut également se produire si la classe référencée n'est pas définie dans un espace de noms en cours d'utilisation ou qui n'a pas été défini en tant que public :

public class Foo{}

class D { function xx() { return 22; } }
var d:D = new D();
var x = new d.xx(); // erreur, la méthode ne peut pas être utilisée en tant que constructeur
function yy() { this.a = 22; }
var z = new yy(); // aucune erreur, les fonctions globales peuvent être utilisées en tant que constructeurs.

public function set gamma(g:Number):Number;

Par contre, le code suivant est valide :

public function set gamma(g:Number):void;

Dans l'exemple suivant, la ligne 3 génère une erreur dans la mesure où aucune fonction set n'est définie pour xx :

class D { function get xx() { return 22; } }
var d:D = new D();
d.xx = 44; // erreur, la propriété est en lecture seule

public int z;// should be 'public var z:int;'

trace "hello"

switch(x)
{
trace(2);
case 0: trace(0); 
break
}

var sum:int = 1 + 2 + ;

Si l'erreur indique « Expecting left parenthesis before _ » (Parenthèse ouvrante attendue devant _), vous avez oublié une parenthèse dans une expression conditionnelle, comme indiqué dans l'exemple suivant, qui est volontairement incorrect :

var fact:int = 1 * 2 * 3;
if fact > 2 {
	var bigger:Boolean = true;
}

var x = (5 > 2) ? 
trace(x)

Le fichier a.as contient les éléments suivants, qui tentent d'inclure le fichier b.as :

import foo.bar.baz;
include "b.as"
trace(2);

Le fichier b.as contient les éléments suivants, qui tentent d'inclure le fichier a.as :

include "a.as"

class a extends b { }
class b extends a { }

Vous utilisez probablement un supertype, alors qu'un sous-type est attendu. Voici un exemple d'utilisation :

class A {}
var a:A = new A(); 
class B extends A { function f() }
var b : B = a // error

La dernière instruction génère une erreur car elle tente d'affecter un objet de type A à une variable de type B.

De même, le code suivant définit la fonction foo(), qui reçoit un paramètre de type B. L'instruction foo(a); génère une erreur car elle tente d'utiliser un paramètre de type A :

function foo(x:B) { }
foo(a);

En outre, l'instruction suivante génère une erreur car la valeur renvoyée pour foo2() doit être de type B :

function foo2():B { return new A(); }

var i:int = 44;
var str:String = i.assortment;

huh = 55;

class A { static function goo(x:int,y:int) 
{ return(x+y); } }

L'instruction suivante générerait une erreur car elle fournit trois arguments :

A.goo(1,2,3);

L'exemple de code suivant attribue correctement le même type à la variable x :

function test()
{
	var x:int = 3;
	for(var x:int = 33; x < 55; x++)
	trace(x);
	for(var x:int = 11; x < 33; x++)
	trace(x)
}

L'exemple de code suivant génère une erreur car l'attribution du type dans la déclaration de variables et dans les boucles for diffèrent :

function test()
{
	var x:String = "La réponse est";
	for(var x:int = 33; x < 55; x++) // erreur
	trace(x);
	for(var x:unit = 11; x < 33; x++) // erreur
	trace(x)
}

interface A {  public function f(); };
class C implements A,A {
public function f() { trace("f"); }
}

L'instruction correcte d'implémentation serait class C implements A {.

function topLevel() { trace("top"); }
topLevel = function() { trace("replacement works in ~");} // error

function f(x):int
{
if (x)
 	return 2;
else
 	return 3;
} // no error

Cependant, la fonction g(x) ci-dessous génère une erreur car l'instruction switch ne renvoie pas toujours une valeur.

function g(x:int):int
{
switch(x)
{
 	case 1: return 1;
 	case 2: return 2:
}
// return 2;//retirez les commentaires pour supprimer l'erreur
}

Cette vérification n'est activée que lorsque la fonction déclare un type de renvoi différent de void.

p.huh = 55;