private _U_ Slice(_U_ startUV, _U_ endUV)
{
int start = startUV.ToInt();
int end = 0;
if (endUV.IsNullNaNUndefined())
{
end = this._value.Length;
}
else
{
end = endUV.ToInt();
}
if (start < 0)
{
start = this._value.Length - Math.Abs(start);
}
if (end < 0)
{
end = this._value.Length - Math.Abs(end);
}
if (start >= this._value.Length || start > end)
{
return(_U_.NewString(""));
}
end = Math.Min(end, this._value.Length);
return(_U_.NewString(this._value.Substring(start, end - start)));
}
public _U_ __CallThis__(string name, _U_ _this, params _U_[] args)
{
if (name.StartsWith("__C__"))
{
if (!(this.Value is _Function))
{
string funName = name.Substring(5);
if (char.IsNumber(name[5]))
{
string[] arrayHL = funName.Split('_');
if (arrayHL.Length == 2)
{
funName = "在行" + arrayHL[0] + "， 列" + arrayHL[1];
}
else
{
funName = string.Empty;
}
}
throw new Exception(funName + " 不是一个有效的函数");
}
return(this.Value.__Call__("", _this, args));
}
else
{
return(this.Value.__Call__(name, _this, args));
}
}
private _U_ Split(_U_ separator, _U_ howmany)
{
var _array = new _Array();
if (separator.IsNullNaNUndefined())
{
_array.__Add__(_U_.NewString(this._value));
return(_U_.New <_Array>(_array));
}
string[] array = this._value.ToSplitStrings(separator.ToString());
string[] newArray = array;
if (!howmany.IsNullNaNUndefined())
{
int length = Math.Min(Math.Max(0, howmany.ToInt(0)), array.Length);
if (length == 0)
{
return(_U_.New <_Array>());
}
if (length < array.Length)
{
newArray = new string[length];
Array.Copy(array, 0, newArray, 0, length);
}
}
foreach (var a in newArray)
{
_array.__Add__(_U_.NewString(a));
}
return(_U_.New <_Array>(_array));
}
private _U_ LastIndexOf(_U_ searchvalue, _U_ fromindex)
{
if (searchvalue.IsNullNaNUndefined())
{
return(_U_.NewNumber(-1));
}
int index = -1;
if (!fromindex.IsNullNaNUndefined())
{
index = fromindex.ToInt(-1);
}
string value = searchvalue.ToString();
//if (index > this._value.Length - 1)
// return _U_.NewNumber(-1);
if (index >= 0 && index < this._value.Length)
{
return(_U_.NewNumber(this._value.LastIndexOf(value, index)));
}
else
{
return(_U_.NewNumber(this._value.LastIndexOf(value)));
}
}
/// <summary>
/// 调用系统
/// </summary>
/// <param name="_this"></param>
/// <param name="pars"></param>
/// <returns></returns>
private _U_ Call(_U_ _this, params _U_[] pars)
{
var result = new _U_(new Undefined());
_delegate(result, _this, pars);
return(result);
}
private _U_ Substr(_U_ startUV, _U_ endUV)
{
int start = startUV.ToInt();
if (start < 0)
{
start = this._value.Length - Math.Abs(start);
}
int length = Math.Max(0, endUV.ToInt(0));
if (start >= this._value.Length || length < 0)
{
return(_U_.NewString(""));
}
if (length == 0)
{
length = this._value.Length - start;
}
else
{
length = Math.Min(length, this._value.Length - start);
}
return(_U_.NewString(this._value.Substring(start, length)));
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="pars"></param>
/// <returns></returns>
public void __Init__(_U_ _this, params _U_[] pars)
{
var result = new _U_(new Undefined());
_delegate(result, _this, pars);
//return this;
}
private _U_ SetValue <T>(_U_ value, Action <T, int[]> callBack)
{
if (this._value == null)
{
return(_U_.Undefined());
}
try {
if (value.IsNullNaNUndefined())
{
this._value = null;
return(_U_.Undefined());
}
var t = ToObject.ConvertTo <T>(value.ToString());
int[] array = new int[7];
array[0] = this._value.Value.Year;
array[1] = this._value.Value.Month;
array[2] = this._value.Value.Day;
array[3] = this._value.Value.Hour;
array[4] = this._value.Value.Minute;
array[5] = this._value.Value.Second;
array[6] = this._value.Value.Millisecond;
this._value = null;
callBack(t, array);
this._value = new DateTime(array[0], array[1], array[2], array[3], array[4], array[5], array[6]);
}
catch {
this._value = null;
}
return(_U_.Undefined());
}
private _U_ Substring(_U_ startUV, _U_ endUV)
{
int start = Math.Max(0, startUV.ToInt());
int end = 0;
if (endUV.Value is Undefined)
{
end = this._value.Length;
}
else
{
end = endUV.ToInt();
}
end = Math.Max(0, end);
int startValue = Math.Min(start, end);
int endValue = Math.Max(start, end);
if (startValue >= this._value.Length)
{
return(_U_.NewString(""));
}
endValue = Math.Min(this._value.Length, endValue);
return(_U_.NewString(this._value.Substring(startValue, endValue - startValue)));
}
public override _U_ __Call__(string name, _U_ _this, params _U_[] args)
{
switch (name)
{
case "concat":
return(this.Concat(args));
case "toLowerCase":
return(this.ToLowerCase());
case "toUpperCase":
return(this.ToUpperCase());
case "charAt":
return(this.CharAt(args.__Get__()));
case "indexOf":
return(this.IndexOf(args.__Get__(), args.__Get__(1)));
case "replace":
return(this.Replace(args.__Get__(), args.__Get__(1)));
case "lastIndexOf":
return(this.LastIndexOf(args.__Get__(), args.__Get__(1)));
case "slice":
return(this.Slice(args.__Get__(), args.__Get__(1)));
case "substr":
return(this.Substr(args.__Get__(), args.__Get__(1)));
case "substring":
return(this.Substring(args.__Get__(), args.__Get__(1)));
case "split":
return(this.Split(args.__Get__(), args.__Get__(1)));
case "trim":
return(Trim(args));
case "contains":
return(Contains(args.__Get__()));
case "startsWith":
return(StartsWith(args.__Get__(), args.__Get__(1)));
case "endsWith":
return(EndsWith(args.__Get__(), args.__Get__(1)));
case "trimStart":
return(TrimStart(args));
case "trimEnd":
return(TrimEnd(args));
default:
return(base.__Call__(name, _this, args));
}
}
private _U_ StartsWith(_U_ uv, _U_ ignoreCase)
{
if (uv.IsNullNaNUndefined())
{
return(_U_.NewBoolean(false));
}
return(_U_.NewBoolean(this._value.StartsWith(uv.ToString(), ignoreCase.Value._Exists, null)));
}
private _U_ Contains(_U_ uv)
{
if (uv.IsNullNaNUndefined())
{
return(_U_.NewBoolean(false));
}
return(_U_.NewBoolean(this._value.Contains(uv.ToString())));
}
public override _U_ __Call__(string name, _U_ _this, params _U_[] args)
{
switch (name)
{
case "":
return(Call(_this, args));
default:
return(base.__Call__(name, _this, args));
}
}
public override _U_ __Call__(string name, _U_ _this, params _U_[] args)
{
switch (name)
{
case "toFixed":
return(_U_.NewNumber(Math.Round(this._value, args.__Get__().ToInt())));
default:
return(base.__Call__(name, _this, args));
}
}
public static bool IsNullNaNUndefined(this _U_ _this)
{
if (_this.Value is NaN || _this.Value is Null || _this.Value is Undefined)
{
return(true);
}
else
{
return(false);
}
}
private static Tuple <long, long> getLong(_U_ t1, _U_ t2)
{
long long1 = 0;
long long2 = 0;
if (t1.Value is _Number)
{
double v1 = (_Number)t1.Value;
if (v1 > long.MaxValue)
{
long1 = long.MaxValue;
}
else
{
long1 = (long)Math.Round(v1);
}
}
else if (t1.Value is _Bool)
{
if ((_Bool)t1.Value == true)
{
long1 = 1;
}
else
{
long1 = 0;
}
}
if (t2.Value is _Number)
{
double v2 = (_Number)t2.Value;
if (v2 > long.MaxValue)
{
long2 = long.MaxValue;
}
else
{
long2 = (long)Math.Round(v2);
}
}
else if (t2.Value is _Bool)
{
if ((_Bool)t2.Value == true)
{
long2 = 1;
}
else
{
long2 = 0;
}
}
return(Tuple.Create(long1, long2));
}
private _U_ CharAt(_U_ index)
{
var i = index.ToInt(0);
if (i < this._value.Length)
{
return(_U_.NewString(this._value[i].ToString()));
}
return(_U_.NewString(""));
}
public static DateTime ToDateTimeForUseVar(this _U_ v, out bool success)
{
DateTime _dt;
success = false;
if (DateTime.TryParse(v.ToString(), out _dt))
{
success = true;
}
return(_dt);
}
public override void SetIndexValue(string key, _U_ value)
{
int index = 0;
if (int.TryParse(key, out index))
{
SetIndexValue(index, value);
}
else
{
base.SetIndexValue(key, value);
}
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="name"></param>
/// <param name="args"></param>
/// <returns></returns>
public virtual _U_ __Call__(string name, _U_ _this, params _U_[] args)
{
_U_ outValue;
if (MethodAndPropery.TryGetValue(name, out outValue))
{
return(outValue.__CallThis__("__C__" + name, _this, args));
}
else
{
return(CallInvoke(name, _this, args));
}
}
private _U_ Replace(_U_ substr, _U_ replacement)
{
if (!(substr.Value is _String))
{
return(_U_.NewString(this._value));
}
if (replacement.IsNullNaNUndefined())
{
return(_U_.NewString(this._value));
}
return(_U_.NewString(this._value.Replace(substr.ToString(), replacement.ToString())));
}
public override _U_ __Call__(string name, _U_ _this, params _U_[] args)
{
switch (name)
{
case "log":
return(Log(args));
case "read":
return(Read());
default:
return(base.__Call__(name, _this, args));
}
}
protected _U_ __AfterSubs__(_U_ u)
{
var d = u.GetValueDoutle();
if (d == null)
{
u.Value = _U_.NaN().Value;
return(_U_.NaN());
}
else
{
u.Value = new _Number(d.Value - 1);
return(_U_.NewNumber(d.Value));
}
}
protected _U_ __BeforeSub__(_U_ u)
{
var d = u.GetValueDoutle();
if (d == null)
{
u.Value = _U_.NaN().Value;
return(_U_.NaN());
}
else
{
u.Value = new _Number(d.Value * -1);
return(u);
}
}
private static double?GetDoubleFor_U_Value(_U_ u)
{
if (u.Value is _Number)
{
return((_Number)u.Value);
}
else if (u.Value is _String)
{
double v = 0;
if (double.TryParse(u.Value.ToString(), out v))
{
return(v);
}
}
return(null);
}
private static Tuple <_Number, _Number> Get_U_Number(_U_ v1, _U_ v2)
{
_Number _number1 = null;
_Number _number2 = null;
if (v1.Value is _Number)
{
_number1 = (_Number)v1.Value;
}
else if (v1.Value is _Bool)
{
if ((_Bool)v1.Value == true)
{
_number1 = new _Number(1);
}
else
{
_number1 = new _Number(0);
}
}
if (v2.Value is _Number)
{
_number2 = (_Number)v2.Value;
}
else if (v2.Value is _Bool)
{
if ((_Bool)v2.Value == true)
{
_number2 = new _Number(1);
}
else
{
_number2 = new _Number(0);
}
}
if (_number1 != null && _number2 != null)
{
return(Tuple.Create(_number1, _number2));
}
else
{
return(null);
}
}
private void ChangeDateForStringOrLong(_U_ par)
{
if (par.Value is _String)
{
bool success = false;
var dt = par.ToDateTimeForUseVar(out success);
if (success)
{
this._value = dt;
}
}
else if (par.Value is _Number)
{
var d = (double)(par.Value as _Number);
DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
this._value = startTime.AddMilliseconds(d);
}
}
public override void __Set__(string name, _U_ value)
{
if (name == "prototype")
{
if (value.Value is _Dictionary)
{
var kvs = (value.Value as _Dictionary).GetValue();
foreach (var kv in kvs)
{
this.MethodAndPropery[kv.Key] = kv.Value;
}
}
}
else
{
base.__Set__(name, value);
}
}
/// <summary>
///
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public override void SetIndexValue(int index, _U_ value)
{
lock (_lockIndex) {
AddValidIndex(index);
if (index < this.arrays.Count)
{
this.arrays[index] = value;
}
else
{
while (index - this.arrays.Count > 0)
{
this.arrays.Add(_U_.Undefined());
}
this.arrays.Add(value);
}
}
}
public override void __Set__(string name, _U_ value)
{
switch (name)
{
case "length":
int length = 0;
if (int.TryParse(value.ToString(), out length))
{
this.SetArrayLength(length);
}
else
{
throw new Exception(value.ToString() + " 不是有效的数组长度");
}
break;
default:
base.__Set__(name, value);
break;
}
}
