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";
    }

Vous pouvez corriger la référence ambiguë en la rendant spécifique. L'exemple suivant utilise la forme espace de nom::fonction pour spécifier quel espace de nom utiliser :

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

public override function foo():void{};

Cette erreur peut également survenir si la classe à laquelle il est fait référence n'est pas définie dans l'espace de nom en cours ou n'est pas définie comme publique :

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 comme constructeur.
function yy() { this.a = 22; }
var z = new yy(); // il n'y a pas d'erreur, les fonctions globales peuvent être utilisées comme 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 troisième ligne engendre une erreur car il n'y a pas de fonction de définition spécifiée 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;// devrait être 'public var z:int;'

import flash.utils.trace;
trace "hello"

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

var sum:int = 1 + 2 + ;

Si l'erreur indique " Parenthèse ouverte attendue avant _, ", vous pouvez avoir omis une parenthèse dans une expression conditionnelle, comme dans l'exemple suivant, qui est incorrect intentionnellement :

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

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

Le fichier a.as contient le code suivant qui tente d'inclure le fichier b.as :

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

Le fichier b.as contient le code suivant qui tente d'inclure le fichier a.as :

include "a.as"

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

Peut-être utilisez-vous un super type 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 // erreur

La dernière instruction cause 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 prend un paramètre de type B. L'instruction foo(a); cause une erreur car elle tente tente d'utiliser un paramètre de type A :

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

L'instruction suivante engendre également 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 causerait une erreur car elle fournit trois arguments :

A.goo(1,2,3);

L'exemple de code suivant force correctement la variable x dans un type équivalent :

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)
}

Le code suivant cause une erreur car le forçage de type dans la déclaration de variable et les boucles for sont différents :

function test()
{
	var x:String = "The answer is";
	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 d'implémentation correcte devrait être class C implements A {.

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

function f(x):int
{
if (x)
    	return 2;
else
    	return 3;
} // absence d'erreur

Cependant, la fonction g(x) ci-dessous occasionne 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;//uncomment to remove the error
}

Cette vérification est activée uniquement si la fonction déclare un type de renvoi autre que nul.

p.huh = 55;